diff --git a/CMakeLists.txt b/CMakeLists.txt
index 73156513748024b6976eb69b627c11188e070b74..ae4a5229fa0fd0eb56a2bf68baa591cfecf2947f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,6 +24,16 @@ if(SCP_FIRMWARE_SOURCE_DIR)
 
     include("${SCP_FIRMWARE_SOURCE_DIR}/Firmware.cmake")
 
+    # create a combined DT_MODULE list.
+    list(APPEND SCP_DT_CONFIG_MODULES_ALL ${SCP_DT_CONFIG_MODULES_STD})
+    list(APPEND SCP_DT_CONFIG_MODULES_ALL ${SCP_DT_CONFIG_MODULES_DYN})
+
+    # temp..
+    message(STATUS "modules = ${SCP_MODULES}")
+    message(STATUS "dt_std_modules = ${SCP_DT_CONFIG_MODULES_STD}")
+    message(STATUS "dt_dyn_modules = ${SCP_DT_CONFIG_MODULES_DYN}")
+    message(STATUS "dt_all_modules = ${SCP_DT_CONFIG_MODULES_ALL}")
+
     if((NOT SCP_FIRMWARE) OR (NOT SCP_FIRMWARE_TARGET))
         # cmake-format: off
         message(FATAL_ERROR
@@ -159,6 +169,14 @@ cmake_dependent_option(
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)
 
+#
+# Stop after C Pre-Processor - allow debug of macros.
+#
+if (SCP_BUILD_CPP_ONLY)
+   string(APPEND CMAKE_C_FLAGS " -E")
+endif()
+
+
 #
 # Set up Cppcheck if it's available and enabled.
 #
@@ -481,14 +499,22 @@ if(SCP_FIRMWARE)
     # support other modules.
     #
 
-    add_subdirectory("module" EXCLUDE_FROM_ALL)
-
+    add_subdirectory("module" EXCLUDE_FROM_ALL)    
+    
     #
     # Load in the framework. This should be the last of the targets we need.
     #
 
     add_subdirectory("framework" EXCLUDE_FROM_ALL)
 
+    #
+    # generate any code needed from .dts files
+    #
+    if(SCP_FIRMWARE_DTS_SOURCE)
+      message(STATUS "Using .dts ${SCP_FIRMWARE_DTS_SOURCE}")
+      include(dts)
+    endif()
+    
     #
     # Collect up all the source files used to build the various targets created
     # above.
diff --git a/Makefile.cmake b/Makefile.cmake
index 6138ee4c493e51a036acd5e9c1b6fdceb9158620..f4296616dba4817f65bde8a9aa7e54f607945783 100644
--- a/Makefile.cmake
+++ b/Makefile.cmake
@@ -119,9 +119,24 @@ ifneq ($(filter-out $(PRODUCT_INDEPENDENT_GOALS), $(MAKECMDGOALS)),)
         $(error "You must define BS_FIRMWARE_LIST in product.mk. Aborting...")
     endif
 
-    FIRMWARE_TARGETS := $(addprefix firmware-, $(BS_FIRMWARE_LIST))
+    ifeq ($(BUILD_TARGET),)
+        FIRMWARE_TARGETS := $(addprefix firmware-, $(BS_FIRMWARE_LIST))
+    else
+        ifneq ($(findstring $(BUILD_TARGET),$(BS_FIRMWARE_LIST)),)
+            FIRMWARE_TARGETS := $(addprefix firmware-, $(BUILD_TARGET))
+        else
+            $(error "Specific BUILD_TARGET $(BUILD_TARGET) not in valid target list: $(BS_FIRMWARE_LIST)")
+        endif
+    endif
+
+	PRODUCT_BUILD_PATH := $(BUILD_PATH)/$(BS_PRODUCT_NAME)/$(TOOLCHAIN)/$(MODE)
 
-PRODUCT_BUILD_PATH := $(BUILD_PATH)/$(BS_PRODUCT_NAME)/$(TOOLCHAIN)/$(MODE)
+	GENERATE_PREFIXES := $(addprefix $(PRODUCT_BUILD_PATH)/, $(FIRMWARE_TARGETS))
+	GENERATE_TARGETS := $(addsuffix /CMakeCache.txt, $(GENERATE_PREFIXES))
+
+    ifneq ($(CPP_HALT),)
+          CPP_HALT_ARGS := -DSCP_BUILD_CPP_ONLY=1
+    endif
 
 define msg_start
 ================================================================
@@ -129,10 +144,12 @@ Arm SCP/MCP Software build System
 Platform    : $(BS_PRODUCT_NAME)
 Mode        : $(MODE)
 Firmware(s) : $(BS_FIRMWARE_LIST)
+Targets(s)  : $(FIRMWARE_TARGETS)
 ================================================================
 endef
 
     $(info $(msg_start))
+
 endif
 
 ifeq ($(MODE),debug)
@@ -154,6 +171,7 @@ endif
 CMAKE_COMMAND_OPTION += $(CMAKE_TOOL_LOG_LEVEL)
 CMAKE_COMMAND_OPTION += $(CMAKE_SCP_LOG_LEVEL_OPTION)
 CMAKE_COMMAND_OPTION += $(CMAKE_DEBUGGER_OPTION)
+CMAKE_COMMAND_OPTION += $(CPP_HALT_ARGS)
 
 #
 # Rules
@@ -169,6 +187,8 @@ help:
 	@echo "| Available Targets                                                |"
 	@echo "--------------------------------------------------------------------"
 	@echo "    all             Build all firmware defined by PRODUCT=<product>"
+	@echo "    generate        Generate all CMake build trees defined by "
+	@echo "                    PRODUCT=<product>."
 	@echo "    clean           Remove all built products"
 	@echo "    help            Show this documentation"
 	@echo ""
@@ -218,6 +238,12 @@ help:
 	@echo "        Default: $(DEFAULT_BUILD_SYSTEM)"
 	@echo "        Specify CMake to generate GNU Make or Ninja build system."
 	@echo ""
+	@echo "    BUILD_TARGET"
+	@echo "        Value: <Single firmware target variant valid for PRODUCT>"
+	@echo "        Default: "
+	@echo "        Specify a named firmware target for the build - otherwise will"
+	@echo "        build all valid firmware targets for the selected PRODUCT"
+	@echo ""
 	@echo "    TOOLCHAIN"
 	@echo "        Value: <GNU|ArmClang|Clang>"
 	@echo "        Default: $(DEFAULT_TOOLCHAIN)"
@@ -231,20 +257,44 @@ help:
 	@echo "        Value: <cmake configuration parameters>"
 	@echo "        Default: "
 	@echo "        Pass extra arguments directly to cmake configuration stage."
-	@echo "        Multiplle extra args can be added with += or by passing the arguments as a string"
+	@echo "        Multiple extra args can be added with += or by passing the arguments as a string"
 	@echo ""
 	@echo "    EXTRA_BUILD_ARGS"
 	@echo "        Value: <cmake build parameters>"
 	@echo "        Default: "
 	@echo "        Pass extra arguments directly to cmake build stage."
-	@echo "        Multiplle extra args can be added with += or by passing the arguments as a string"
+	@echo "        Multiple extra args can be added with += or by passing the arguments as a string"
+	@echo ""
+	@echo "    CPP_HALT"
+	@echo "        Value: 1 "
+	@echo "        Default: "
+	@echo "        Halt after the C Pre-Processor stage - use to debug macro expansion"
 	@echo ""
-
 
 .SECONDEXPANSION:
 
 .PHONY: all
-all: $(FIRMWARE_TARGETS)
+all: command_msg $(FIRMWARE_TARGETS)
+
+define msg_generate
+================================================================
+Generate only: $(GENERATE_TARGETS)
+================================================================
+endef
+
+.PHONY: generate
+generate: generate_msg $(GENERATE_TARGETS)
+
+generate_msg:
+	$(info $(msg_generate))
+
+
+define msg_cmd
+CMake Commnd options: $(CMAKE_COMMAND_OPTION)
+endef
+
+command_msg:
+    $(info $(msg_cmd))
 
 firmware-%: $(PRODUCT_BUILD_PATH)/$$@/CMakeCache.txt
 	$(CMAKE) --build $(<D)/ $(CMAKE_BUILD_VERBOSE_OPTION) $(EXTRA_BUILD_ARGS)
diff --git a/cmake/dts.cmake b/cmake/dts.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..c3c4af801fce8d31306feab0c6e13e6009d600da
--- /dev/null
+++ b/cmake/dts.cmake
@@ -0,0 +1,167 @@
+#
+# Arm SCP/MCP Software
+# Copyright (c) 2021, Arm Limited and Contributors. All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+
+# Function to help set dependencies on .dts files
+# (copied from zephyr project)
+#
+# 'toolchain_parse_make_rule' is a function that parses the output of
+# 'gcc -M'.
+#
+# The argument 'input_file' is in input parameter with the path to the
+# file with the dependency information.
+#
+# The argument 'include_files' is an output parameter with the result
+# of parsing the include files.
+function(toolchain_parse_make_rule input_file include_files)
+  file(READ ${input_file} input)
+
+  # The file is formatted like this:
+  # empty_file.o: misc/empty_file.c \
+  # nrf52840dk_nrf52840/nrf52840dk_nrf52840.dts \
+  # nrf52840_qiaa.dtsi
+
+  # Get rid of the backslashes
+  string(REPLACE "\\" ";" input_as_list ${input})
+
+  # Pop the first line and treat it specially
+  list(GET input_as_list 0 first_input_line)
+  string(FIND ${first_input_line} ": " index)
+  math(EXPR j "${index} + 2")
+  string(SUBSTRING ${first_input_line} ${j} -1 first_include_file)
+  list(REMOVE_AT input_as_list 0)
+
+  list(APPEND result ${first_include_file})
+
+  # Add the other lines
+  list(APPEND result ${input_as_list})
+
+  # Strip away the newlines and whitespaces
+  list(TRANSFORM result STRIP)
+
+  set(${include_files} ${result} PARENT_SCOPE)
+endfunction()
+
+# Use .dts files to configure modules if selected in project.
+#
+# device tree bindings are used to populate configuration tables in the firmware
+#
+
+# set up the generator tool 
+set(DTS_GEN_SCRIPT ${CMAKE_SOURCE_DIR}/tools/dts/dt_gen_config.py)
+set(PYTHON_EXEC python3)
+
+# output working directory for dts elements
+set(DTS_BIN_DIR ${CMAKE_BINARY_DIR}/dts)
+file(MAKE_DIRECTORY ${DTS_BIN_DIR})
+set(DTS_HEADER_DIR ${CMAKE_BINARY_DIR}/framework/include)
+file(MAKE_DIRECTORY ${DTS_HEADER_DIR})
+
+# set up source directories used by common .dts / .dtsi files
+set(DTS_SRC_COMMON ${CMAKE_SOURCE_DIR}/dts/src)
+set(DTS_SRC_COMMON_INC ${CMAKE_SOURCE_DIR}/dts/include)
+
+set(DTS_CPP_TEMP_OUT ${DTS_BIN_DIR}/${SCP_FIRMWARE}.dts.pre.tmp)
+set(DTS_CPP_DEPS_OUT ${DTS_BIN_DIR}/${SCP_FIRMWARE}.dts.pre.d)
+set(DTS_EDT_PICKLE_OUT   ${DTS_BIN_DIR}/edt.pickle)
+set(DTS_FWK_HEADER_OUT ${DTS_HEADER_DIR}/fwk_dt_config.h)
+set(DTS_VENDOR_PREFIXES ${CMAKE_SOURCE_DIR}/dts/bindings/vendor-prefixes.txt)
+set(DTS_GEN_DTS_DBG_OUT ${DTS_BIN_DIR}/${SCP_FIRMWARE}.dts.out)
+set(DTS_BINDINGS_DIRS ${CMAKE_SOURCE_DIR}/dts/bindings) 
+
+message(STATUS "compiling devicetree files: ${SCP_FIRMWARE_DTS_SOURCE} using ${DTS_GEN_SCRIPT}")
+
+# add framework includes for common bindings - fixed & generated.
+list(APPEND SCP_FIRMWARE_DTS_INCLUDE "${CMAKE_SOURCE_DIR}/framework/include")
+list(APPEND SCP_FIRMWARE_DTS_INCLUDE "${CMAKE_BINARY_DIR}/framework/include")
+
+# list of dts include source dirs
+list(APPEND
+    DTS_INC
+    ${DTS_SRC_COMMON}
+    ${DTS_SRC_COMMON_INC}
+    ${SCP_FIRMWARE_DTS_INCLUDE}
+    )
+message(STATUS "DTS_INC dirs ${DTS_INC}")
+
+
+# need to call preprocessor and generator if the product has a .dts file
+if(SCP_FIRMWARE_DTS_SOURCE)
+    # C Pre-Processor on dts & dtsi to create output temp file
+    # create include command line flags for CPP 
+    unset(DTS_INC_FLAG_CPP)
+    set(DTS_INC_FLAG_CPP
+        -include ${SCP_FIRMWARE_DTS_SOURCE}
+        )
+    message(STATUS "DTS inc ${DTS_INC_FLAG_CPP}")
+
+    # create system include dir flags for CPP
+    unset(DTS_SYSTEM_INC_DIR_FLAG_CPP)
+    foreach(dts_inc_dir ${DTS_INC})
+        get_filename_component(full_path ${dts_inc_dir} REALPATH)
+        list(APPEND
+            DTS_SYSTEM_INC_DIR_FLAG_CPP
+            -isystem ${full_path}
+            )
+    endforeach()
+    message(STATUS "DTS INC flags : ${DTS_SYSTEM_INC_DIR_FLAG_CPP}")
+    execute_process(
+        COMMAND  ${CMAKE_C_COMPILER}
+        -x assembler-with-cpp
+        -nostdinc
+        -undef
+        -D DTS_COMPILE
+        ${DTS_SYSTEM_INC_DIR_FLAG_CPP} # dts include dirs as -isystem <path>  options
+        ${DTS_INC_FLAG_CPP}            # dts source as -include <source> options
+        -P
+        -E   # stop after pre-processing
+        -MD  # generate deps file
+        -MF  ${DTS_CPP_DEPS_OUT}
+        -o  ${DTS_CPP_TEMP_OUT}
+        ${CMAKE_SOURCE_DIR}/dts/misc/empty_file.c 
+        WORKING_DIRECTORY ${DTS_BIN_DIR}
+        RESULT_VARIABLE ret
+        )
+    if(NOT "${ret}" STREQUAL "0")
+           message(FATAL_ERROR "C pre-process command failed with return code: ${ret}")
+    endif()
+    
+    # run generator on preprocessed temp file.
+    set(CMD_GEN_CFG ${PYTHON_EXEC} ${DTS_GEN_SCRIPT}
+        --dts ${DTS_CPP_TEMP_OUT}
+        --scp-base-dir ${CMAKE_SOURCE_DIR}
+        --header-out ${DTS_FWK_HEADER_OUT}
+        --dts-out ${DTS_GEN_DTS_DBG_OUT} # As a debugging aid
+        --bindings-dirs ${DTS_BINDINGS_DIRS}
+        --edt-pickle-out ${DTS_EDT_PICKLE_OUT}
+        --vendor-prefixes ${DTS_VENDOR_PREFIXES}
+        --dtc-flags "none"
+        --verbose 1
+    )
+    message(STATUS "command used: ${CMD_GEN_CFG} raw3 in ${DTS_BIN_DIR}")  
+    execute_process(
+        COMMAND ${CMD_GEN_CFG}
+        WORKING_DIRECTORY ${DTS_BIN_DIR}
+        COMMAND_ERROR_IS_FATAL ANY
+    )
+
+    # add dependencies from processed .dts file
+    # Parse the generated dependency file to find the DT sources that
+    # were included and then add them to the list of files that trigger
+    # a re-run of CMake.
+    toolchain_parse_make_rule(
+        ${DTS_CPP_DEPS_OUT}
+        include_files # Output parameter
+        )
+
+    set_property(DIRECTORY APPEND PROPERTY
+        CMAKE_CONFIGURE_DEPENDS
+        ${include_files}
+        ${DTS_GEN_SCRIPT}
+        )
+
+endif()
diff --git a/doc/Doxyfile b/doc/Doxyfile
index 4b3bf550bab4ab66ea802dba2eee79a38c960011..df6ce36540e3996b0dae3d1df5881a57b294b2b1 100644
--- a/doc/Doxyfile
+++ b/doc/Doxyfile
@@ -800,6 +800,7 @@ INPUT                  = $(TOP_DIR)/readme.md \
                          $(DOC_DIR)/framework.md \
                          $(DOC_DIR)/cmsis.md \
                          $(DOC_DIR)/glossary.md \
+                         $(DOC_DIR)/cmake_readme.md \
                          $(DOC_DIR)/deferred_response_architecture.md \
                          $(DOC_DIR)/architecture_support.md \
                          $(FWK_DIR)/include \
diff --git a/dts/bindings/arm,pl011.yaml b/dts/bindings/arm,pl011.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3ce0e9464f3747846ffac88ae5d0050312787c57
--- /dev/null
+++ b/dts/bindings/arm,pl011.yaml
@@ -0,0 +1,19 @@
+description: ARM PL011 UART
+
+compatible: "arm,pl011"
+
+include: uart-controller.yaml
+
+properties:
+    reg:
+      required: true
+
+      # MJL: changed to false
+    interrupts:
+      required: false
+
+    pd-id:
+      type: int
+      required: false
+      description: Power domain index for the component
+
diff --git a/dts/bindings/base.yaml b/dts/bindings/base.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..1e489401e83612df40a0ff53bcf1626b628c6b56
--- /dev/null
+++ b/dts/bindings/base.yaml
@@ -0,0 +1,99 @@
+# Common fields for all devices
+
+include: [pm.yaml]
+
+properties:
+    status:
+        type: string
+        required: false
+        description: indicates the operational status of a device
+        enum:
+           - "ok" # Deprecated form
+           - "okay"
+           - "disabled"
+           - "reserved"
+           - "fail"
+           - "fail-sss"
+
+    compatible:
+        type: string-array
+        required: true
+        description: compatible strings
+
+    reg:
+        type: array
+        description: register space
+        required: false
+
+    reg-names:
+        type: string-array
+        description: name of each register space
+        required: false
+
+    interrupts:
+        type: array
+        required: false
+        description: interrupts for device
+
+    # Does not follow the 'type: phandle-array' scheme, but gets type-checked
+    # by the code. Declare it here just so that other bindings can make it
+    # 'required: true' easily if they want to.
+    interrupts-extended:
+        type: compound
+        required: false
+        description: extended interrupt specifier for device
+
+    interrupt-names:
+        type: string-array
+        required: false
+        description: name of each interrupt
+
+    interrupt-parent:
+        type: phandle
+        required: false
+        description: phandle to interrupt controller node
+
+    label:
+        type: string
+        required: false
+        description: Human readable string describing the device (used as device_get_binding() argument)
+
+    clocks:
+        type: phandle-array
+        required: false
+        description: Clock gate information
+
+    clock-names:
+        type: string-array
+        required: false
+        description: name of each clock
+
+    "#address-cells":
+        type: int
+        required: false
+        description: number of address cells in reg property
+
+    "#size-cells":
+        type: int
+        required: false
+        description: number of size cells in reg property
+
+    dmas:
+      required: false
+      type: phandle-array
+      description: DMA channels specifiers
+
+    dma-names:
+      required: false
+      type: string-array
+      description: Provided names of DMA channel specifiers
+
+    io-channels:
+      required: false
+      type: phandle-array
+      description: IO channels specifiers
+
+    io-channel-names:
+      required: false
+      type: string-array
+      description: Provided names of IO channel specifiers
diff --git a/dts/bindings/pm.yaml b/dts/bindings/pm.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a0d3bae20335c9d6c6d75b7f2e2d0a1d2fbd6012
--- /dev/null
+++ b/dts/bindings/pm.yaml
@@ -0,0 +1,18 @@
+# Copyright (c) 2021 Intel Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# Properties for Power Management (PM)
+
+properties:
+    wakeup-source:
+      required: false
+      type: boolean
+      description: |
+        Property to identify that a device can be used as wake up source.
+
+        When this property is provided a specific flag is set into the
+        device that tells the system that the device is capable of
+        wake up the system.
+
+        Wake up capable devices are disabled (interruptions will not wake up
+        the system) by default but they can be enabled at runtime if necessary.
diff --git a/dts/bindings/uart-controller.yaml b/dts/bindings/uart-controller.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d2674e14d979ecf5341f5e0648185d7f0c31cf56
--- /dev/null
+++ b/dts/bindings/uart-controller.yaml
@@ -0,0 +1,31 @@
+# Common fields for UART controllers
+
+include: base.yaml
+
+bus: uart
+
+properties:
+    clock-frequency:
+      type: int
+      required: false
+      description: Clock frequency information for UART operation
+    current-speed:
+      type: int
+      required: false
+      description: Initial baud rate setting for UART
+    label:
+      required: true
+    hw-flow-control:
+      type: boolean
+      required: false
+      description: Set to enable RTS/CTS flow control at boot time
+    parity:
+      required: false
+      type: string
+      description: |
+        Configures the parity of the adapter. Enumeration id 0 for none, 1 for odd
+        and 2 for even parity. Default to none if not specified.
+      enum:
+        - "none"
+        - "odd"
+        - "even"
diff --git a/dts/bindings/vendor-prefixes.txt b/dts/bindings/vendor-prefixes.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f59a750f82b518d305c6b513cce1dec62450c489
--- /dev/null
+++ b/dts/bindings/vendor-prefixes.txt
@@ -0,0 +1,669 @@
+# Device tree binding vendor prefix registry. Keep this list in
+# alphabetical order.
+#
+# This isn't an exhaustive list, but you should add new prefixes to it
+# before using them to avoid name-space collisions.
+#
+# The contents of this file are parsed during documentation generation.
+# Anything that starts with a '#' is treated as a comment and ignored.
+# Non-empty lines should be in this format:
+#
+# <vendor-prefix><TAB><Full name of vendor>
+
+abb	ABB
+abilis	Abilis Systems
+abracon	Abracon Corporation
+abt	ShenZhen Asia Better Technology Ltd.
+acer	Acer Inc.
+acme	Acme Systems srl
+actions	Actions Semiconductor Co., Ltd.
+active-semi	Active-Semi International Inc
+ad	Avionic Design GmbH
+adafruit	Adafruit Industries, LLC
+adapteva	Adapteva, Inc.
+adaptrum	Adaptrum, Inc.
+adh	AD Holdings Plc.
+adi	Analog Devices, Inc.
+advantech	Advantech Corporation
+aeroflexgaisler	Aeroflex Gaisler AB
+aesop	AESOP Embedded Forum
+al	Annapurna Labs
+alcatel	Alcatel
+allegro	Allegro DVT
+allo	Allo.com
+allwinner	Allwinner Technology Co., Ltd.
+alphascale	AlphaScale Integrated Circuits Systems, Inc.
+alps	Alps Electric Co., Ltd.
+alt	Altus-Escon-Company BV
+altr	Altera Corp.
+amarula	Amarula Solutions
+amazon	Amazon.com, Inc.
+amcc	Applied Micro Circuits Corporation (APM, formally AMCC)
+amd	Advanced Micro Devices (AMD), Inc.
+amediatech	Shenzhen Amediatech Technology Co., Ltd
+amlogic	Amlogic, Inc.
+ampere	Ampere Computing LLC
+ampire	Ampire Co., Ltd.
+ams	AMS AG
+amstaos	AMS-Taos Inc.
+analogix	Analogix Semiconductor, Inc.
+andestech	Andes Technology Corporation
+anvo	Anvo-Systems Dresden GmbH
+apm	Applied Micro Circuits Corporation (APM)
+apple	Apple Inc.
+aptina	Aptina Imaging
+arasan	Arasan Chip Systems
+archermind	ArcherMind Technology (Nanjing) Co., Ltd.
+arctic	Arctic Sand
+arcx	arcx Inc. / Archronix Inc.
+arduino	Arduino
+aries	Aries Embedded GmbH
+arm	ARM Ltd.
+armadeus	ARMadeus Systems SARL
+arrow	Arrow Electronics
+artesyn	Artesyn Embedded Technologies Inc.
+asahi-kasei	Asahi Kasei Corp.
+asmedia	ASMedia Technology Inc.
+asc	All Sensors Corporation
+aspeed	ASPEED Technology Inc.
+asus	AsusTek Computer Inc.
+atlas	Atlas Scientific LLC
+atmel	Atmel Corporation
+auo	AU Optronics Corporation
+auvidea	Auvidea GmbH
+avago	Avago Technologies
+avia	avia semiconductor
+avic	Shanghai AVIC Optoelectronics Co., Ltd.
+avnet	Avnet, Inc.
+awinic	Shanghai Awinic Technology Co., Ltd.
+axentia	Axentia Technologies AB
+axis	Axis Communications AB
+azoteq	Azoteq (Pty) Ltd
+azw	Shenzhen AZW Technology Co., Ltd.
+baikal	BAIKAL ELECTRONICS, JSC
+bananapi	BIPAI KEJI LIMITED
+beacon	Compass Electronics Group, LLC
+beagle	BeagleBoard.org Foundation
+bhf	Beckhoff Automation GmbH & Co. KG
+bitmain	Bitmain Technologies
+blutek	BluTek Power
+boe	BOE Technology Group Co., Ltd.
+bosch	Bosch Sensortec GmbH
+boundary	Boundary Devices Inc.
+broadmobi	Shanghai Broadmobi Communication Technology Co.,Ltd.
+brcm	Broadcom Corporation
+buffalo	Buffalo, Inc.
+bur	B&R Industrial Automation GmbH
+bticino	Bticino International
+cadence	Cadence Design Systems, Inc.
+calaosystems	CALAO Systems SAS
+calxeda	Calxeda
+canaan	Canaan, Inc.
+caninos	Caninos Loucos Program
+capella	Capella Microsystems, Inc
+cascoda	Cascoda, Ltd.
+catalyst	Catalyst Semiconductor, Inc.
+cavium	Cavium, Inc.
+cdns	Cadence Design Systems Inc.
+cdtech	CDTech(H.K.) Electronics Limited
+cellwise	CellWise Microelectronics Co., Ltd
+ceva	Ceva, Inc.
+checkpoint	Check Point Software Technologies Ltd.
+chefree	Chefree Technology Corp.
+chipidea	Chipidea, Inc
+chipone	ChipOne
+chipspark	ChipSPARK
+chrontel	Chrontel, Inc.
+chrp	Common Hardware Reference Platform
+chunghwa	Chunghwa Picture Tubes Ltd.
+chuwi	Chuwi Innovation Ltd.
+ciaa	Computadora Industrial Abierta Argentina
+cirrus	Cirrus Logic, Inc.
+cisco	Cisco Systems, Inc.
+cloudengines	Cloud Engines, Inc.
+cnm	Chips&Media, Inc.
+cnxt	Conexant Systems, Inc.
+colorfly	Colorful GRP, Shenzhen Xueyushi Technology Ltd.
+compulab	CompuLab Ltd.
+coreriver	CORERIVER Semiconductor Co.,Ltd.
+corpro	Chengdu Corpro Technology Co., Ltd.
+cortina	Cortina Systems, Inc.
+cosmic	Cosmic Circuits
+crane	Crane Connectivity Solutions
+creative	Creative Technology Ltd
+crystalfontz	Crystalfontz America, Inc.
+csky	Hangzhou C-SKY Microsystems Co., Ltd
+csq	Shenzen Chuangsiqi Technology Co.,Ltd.
+cubietech	Cubietech, Ltd.
+cypress	Cypress Semiconductor Corporation
+cznic	CZ.NIC, z.s.p.o.
+dallas	Maxim Integrated Products (formerly Dallas Semiconductor)
+dataimage	DataImage, Inc.
+davicom	DAVICOM Semiconductor, Inc.
+dell	Dell Inc.
+delta	Delta Electronics, Inc.
+denx	Denx Software Engineering
+devantech	Devantech, Ltd.
+dfi	DFI Inc.
+dh	DH electronics GmbH
+difrnce	Shenzhen Yagu Electronic Technology Co., Ltd.
+digi	Digi International Inc.
+digilent	Diglent, Inc.
+dioo	Dioo Microcircuit Co., Ltd
+dlc	DLC Display Co., Ltd.
+dlg	Dialog Semiconductor
+dlink	D-Link Corporation
+dmo	Data Modul AG
+domintech	Domintech Co., Ltd.
+dongwoon	Dongwoon Anatech
+dptechnics	DPTechnics
+dragino	Dragino Technology Co., Limited
+dserve	dServe Technology B.V.
+dynaimage	Dyna-Image
+ea	Embedded Artists AB
+ebang	Zhejiang Ebang Communication Co., Ltd
+ebs-systart	EBS-SYSTART GmbH
+ebv	EBV Elektronik
+eckelmann	Eckelmann AG
+edt	Emerging Display Technologies
+eeti	eGalax_eMPIA Technology Inc
+einfochips	Einfochips
+elan	Elan Microelectronic Corp.
+element14	Element14 (A Premier Farnell Company)
+elgin	Elgin S/A.
+elida	Shenzhen Elida Technology Co., Ltd.
+elimo	Elimo Engineering Ltd.
+embest	Shenzhen Embest Technology Co., Ltd.
+emlid	Emlid, Ltd.
+emmicro	EM Microelectronic
+empire-electronix	Empire Electronix
+emtrion	emtrion GmbH
+endless	Endless Mobile, Inc.
+ene	ENE Technology, Inc.
+energymicro	Silicon Laboratories (formerly Energy Micro AS)
+engicam	Engicam S.r.l.
+epcos	EPCOS AG
+epfl	Ecole Polytechnique Fédérale de Lausanne
+epson	Seiko Epson Corp.
+espressif	Espressif Systems
+est	ESTeem Wireless Modems
+ettus	NI Ettus Research
+eukrea	Eukréa Electromatique
+everest	Everest Semiconductor Co. Ltd.
+everspin	Everspin Technologies, Inc.
+evervision	Evervision Electronics Co. Ltd.
+exar	Exar Corporation
+excito	Excito
+ezchip	EZchip Semiconductor
+facebook	Facebook
+fairphone	Fairphone B.V.
+faraday	Faraday Technology Corporation
+fastrax	Fastrax Oy
+fcs	Fairchild Semiconductor
+feixin	Shenzhen Feixin Photoelectic Co., Ltd
+feiyang	Shenzhen Fly Young Technology Co.,LTD.
+fii	Foxconn Industrial Internet
+firefly	Firefly
+focaltech	FocalTech Systems Co.,Ltd
+frida	Shenzhen Frida LCD Co., Ltd.
+friendlyarm	Guangzhou FriendlyARM Computer Tech Co., Ltd
+fsl	Freescale Semiconductor
+fujitsu	Fujitsu Ltd.
+gaisler	Gaisler
+gardena	GARDENA GmbH
+gateworks	Gateworks Corporation
+gcw	Game Consoles Worldwide
+ge	General Electric Company
+geekbuying	GeekBuying
+gef	GE Fanuc Intelligent Platforms Embedded Systems, Inc.
+GEFanuc	GE Fanuc Intelligent Platforms Embedded Systems, Inc.
+gemei	Gemei Digital Technology Co., Ltd.
+geniatech	Geniatech, Inc.
+giantec	Giantec Semiconductor, Inc.
+giantplus	Giantplus Technology Co., Ltd.
+globalscale	Globalscale Technologies, Inc.
+globaltop	GlobalTop Technology, Inc.
+gmt	Global Mixed-mode Technology, Inc.
+goodix	Shenzhen Huiding Technology Co., Ltd.
+google	Google, Inc.
+grinn	Grinn
+grmn	Garmin Limited
+gumstix	Gumstix, Inc.
+hannstar	HannStar Display Corporation
+haoyu	Haoyu Microelectronic Co. Ltd.
+hardkernel	Hardkernel Co., Ltd
+hideep	HiDeep Inc.
+himax	Himax Technologies, Inc.
+hirschmann	Hirschmann Automation and Control GmbH
+hisilicon	Hisilicon Limited.
+hit	Hitachi Ltd.
+hitex	Hitex Development Tools
+holt	Holt Integrated Circuits, Inc.
+honestar	Honestar Technologies Co., Ltd.
+honeywell	Honeywell
+hoperun	Jiangsu HopeRun Software Co., Ltd.
+hp	Hewlett Packard
+hsg	HannStar Display Co.
+holtek	Holtek Semiconductor, Inc.
+hugsun	Shenzhen Hugsun Technology Co. Ltd.
+hwacom	HwaCom Systems Inc.
+hycon	Hycon Technology Corp.
+hydis	Hydis Technologies
+hyundai	Hyundai Technology
+i2se	I2SE GmbH
+ibm	International Business Machines (IBM)
+icplus	IC Plus Corp.
+idt	Integrated Device Technologies, Inc.
+ifi	Ingenieurburo Fur Ic-Technologie (I/F/I)
+ilitek	ILI Technology Corporation (ILITEK)
+img	Imagination Technologies Ltd.
+imi	Integrated Micro-Electronics Inc.
+incircuit	In-Circuit GmbH
+inet-tek	Shenzhen iNet Mobile Internet Technology Co., Ltd
+infineon	Infineon Technologies
+inforce	Inforce Computing
+ivo	InfoVision Optoelectronics Kunshan Co. Ltd.
+ingenic	Ingenic Semiconductor
+innolux	Innolux Corporation
+inside-secure	INSIDE Secure
+inspur	Inspur Corporation
+intel	Intel Corporation
+intercontrol	Inter Control Group
+invensense	InvenSense Inc.
+inversepath	Inverse Path
+iom	Iomega Corporation
+isee	ISEE 2007 S.L.
+isil	Intersil
+issi	Integrated Silicon Solutions Inc.
+ite	ITE Tech. Inc.
+itead	ITEAD Intelligent Systems Co.Ltd
+iwave	iWave Systems Technologies Pvt. Ltd.
+jdi	Japan Display Inc.
+jedec	JEDEC Solid State Technology Association
+jesurun	Shenzhen Jesurun Electronics Business Dept.
+jianda	Jiandangjing Technology Co., Ltd.
+kam	Kamstrup A/S
+karo	Ka-Ro electronics GmbH
+keithkoep	Keith & Koep GmbH
+keymile	Keymile GmbH
+khadas	Khadas
+kiebackpeter	Kieback & Peter GmbH
+kinetic	Kinetic Technologies
+kingdisplay	King & Display Technology Co., Ltd.
+kingnovel	Kingnovel Technology Co., Ltd.
+kionix	Kionix, Inc.
+kobo	Rakuten Kobo Inc.
+kobol	Kobol Innovations Pte. Ltd.
+koe	Kaohsiung Opto-Electronics Inc.
+kontron	Kontron S&T AG
+kosagi	Sutajio Ko-Usagi PTE Ltd.
+kvg	Kverneland Group
+kyo	Kyocera Corporation
+lacie	LaCie
+laird	Laird PLC
+lairdconnect	Laird Connectivity
+lamobo	Ketai Huajie Technology Co., Ltd.
+lantiq	Lantiq Semiconductor
+lattice	Lattice Semiconductor
+leadtek	Shenzhen Leadtek Technology Co., Ltd.
+leez	Leez
+lego	LEGO Systems A/S
+lemaker	Shenzhen LeMaker Technology Co., Ltd.
+lenovo	Lenovo Group Ltd.
+lg	LG Corporation
+lgphilips	LG Display
+libretech	Shenzhen Libre Technology Co., Ltd
+licheepi	Lichee Pi
+linaro	Linaro Limited
+linksprite	LinkSprite Technologies, Inc.
+linksys	Belkin International, Inc. (Linksys)
+linutronix	Linutronix GmbH
+linux	Linux-specific binding
+linx	Linx Technologies
+litex	LiteX SoC builder
+lltc	Linear Technology Corporation
+logicpd	Logic PD, Inc.
+logictechno	Logic Technologies Limited
+longcheer	Longcheer Technology (Shanghai) Co., Ltd.
+lontium	Lontium Semiconductor Corporation
+loongson	Loongson Technology Corporation Limited
+lsi	LSI Corp. (LSI Logic)
+lwn	Liebherr-Werk Nenzing GmbH
+lxa	Linux Automation GmbH
+m5stack	M5Stack
+macnica	Macnica Americas
+mantix	Mantix Display Technology Co.,Ltd.
+mapleboard	Mapleboard.org
+marvell	Marvell Technology Group Ltd.
+maxbotix	MaxBotix Inc.
+maxim	Maxim Integrated Products
+mbvl	Mobiveil Inc.
+mcube	mCube
+meas	Measurement Specialties
+mecer	Mustek Limited
+mediatek	MediaTek Inc.
+megachips	MegaChips
+mele	Shenzhen MeLE Digital Technology Ltd.
+melexis	Melexis N.V.
+melfas	MELFAS Inc.
+mellanox	Mellanox Technologies
+memsic	MEMSIC Inc.
+menlo	Menlo Systems GmbH
+mentor	Mentor Graphics
+meraki	Cisco Meraki, LLC
+merrii	Merrii Technology Co., Ltd.
+micrel	Micrel Inc.
+microchip	Microchip Technology Inc.
+microcrystal	Micro Crystal AG
+micron	Micron Technology Inc.
+microsoft	Microsoft Corporation
+microsys	MicroSys Electronics GmbH
+mikroe	MikroElektronika d.o.o.
+mikrotik	MikroTik
+miniand	Miniand Tech
+minix	MINIX Technology Ltd.
+miramems	MiraMEMS Sensing Technology Co., Ltd.
+mitsubishi	Mitsubishi Electric Corporation
+modtronix	Modtronix Engineering
+mosaixtech	Mosaix Technologies, Inc.
+motorola	Motorola, Inc.
+moxa	Moxa Inc.
+mpl	MPL AG
+mps	Monolithic Power Systems Inc.
+mqmaker	mqmaker Inc.
+mrvl	Marvell Technology Group Ltd.
+mscc	Microsemi Corporation
+msi	Micro-Star International Co. Ltd.
+mstar	MStar Semiconductor, Inc. (acquired by MediaTek Inc.)
+mti	Imagination Technologies Ltd. (formerly MIPS Technologies Inc.)
+multi-inno	Multi-Inno Technology Co.,Ltd
+mundoreader	Mundo Reader S.L.
+murata	Murata Manufacturing Co., Ltd.
+mxicy	Macronix International Co., Ltd.
+myir	MYIR Tech Limited
+national	National Semiconductor
+nec	NEC LCD Technologies, Ltd.
+neonode	Neonode Inc.
+netgear	NETGEAR
+netlogic	Broadcom Corporation (formerly NetLogic Microsystems)
+netron-dy	Netron DY
+netronix	Netronix, Inc.
+netxeon	Shenzhen Netxeon Technology CO., LTD
+neweast	Guangdong Neweast Optoelectronics CO., LTD
+nexbox	Nexbox
+nextthing	Next Thing Co.
+newhaven	Newhaven Display International
+ni	National Instruments
+nintendo	Nintendo
+nlt	NLT Technologies, Ltd.
+nokia	Nokia
+nordic	Nordic Semiconductor
+novtech	NovTech, Inc.
+nutsboard	NutsBoard
+nuvoton	Nuvoton Technology Corporation
+nvd	New Vision Display
+nvidia	NVIDIA
+nxp	NXP Semiconductors
+oceanic	Oceanic Systems (UK) Ltd.
+oct	Octavo Systems LLC
+okaya	Okaya Electric America, Inc.
+oki	Oki Electric Industry Co., Ltd.
+olimex	OLIMEX Ltd.
+olpc	One Laptop Per Child
+ovti	OmniVision Technologies Co., Ltd.
+onion	Onion Corporation
+onnn	ON Semiconductor Corp.
+ontat	On Tat Industrial Company
+opalkelly	Opal Kelly Incorporated
+opencores	OpenCores.org
+openisa	open-isa.org
+openrisc	OpenRISC.io
+option	Option NV
+oranth	Shenzhen Oranth Technology Co., Ltd.
+ORCL	Oracle Corporation
+orisetech	Orise Technology
+ortustech	Ortus Technology Co., Ltd.
+osddisplays	OSD Displays
+ouya	Ouya Inc.
+overkiz	Overkiz SAS
+ovti	OmniVision Technologies
+oxsemi	Oxford Semiconductor, Ltd.
+ozzmaker	OzzMaker
+panasonic	Panasonic Corporation
+parade	Parade Technologies Inc.
+particle	Particle.io
+parallax	Parallax Inc.
+pda	Precision Design Associates, Inc.
+pericom	Pericom Technology Inc.
+pervasive	Pervasive Displays, Inc.
+phicomm	PHICOMM Co., Ltd.
+phytec	PHYTEC Messtechnik GmbH
+picochip	Picochip Ltd
+pine64	Pine64
+pineriver	Shenzhen PineRiver Designs Co., Ltd.
+pixcir	PIXCIR MICROELECTRONICS Co., Ltd
+plantower	Plantower Co., Ltd
+plathome	Plat'Home Co., Ltd.
+plda	PLDA
+plx	Broadcom Corporation (formerly PLX Technology)
+ply	Plymovent Group BV
+pni	PNI Sensor Corporation
+pocketbook	PocketBook International SA
+polaroid	Polaroid Corporation
+portwell	Portwell Inc.
+poslab	Poslab Technology Co., Ltd.
+pov	Point of View International B.V.
+powertip	Powertip Tech. Corp.
+powervr	PowerVR (deprecated, use img)
+primux	Primux Trading, S.L.
+probox2	PROBOX2 (by W2COMP Co., Ltd.)
+prt	Protonic Holland
+pulsedlight	PulsedLight, Inc
+purism	Purism, SPC
+qca	Qualcomm Atheros, Inc.
+qcom	Qualcomm Technologies, Inc
+qemu	QEMU, a generic and open source machine emulator and virtualizer
+qi	Qi Hardware
+qihua	Chengdu Kaixuan Information Technology Co., Ltd.
+qiaodian	QiaoDian XianShi Corporation
+qnap	QNAP Systems, Inc.
+quicklogic	QuickLogic Corp.
+radxa	Radxa
+raidsonic	RaidSonic Technology GmbH
+ralink	Mediatek/Ralink Technology Corp.
+ramtron	Ramtron International
+raspberrypi	Raspberry Pi Foundation
+raydium	Raydium Semiconductor Corp.
+rda	Unisoc Communications, Inc.
+realtek	Realtek Semiconductor Corp.
+remarkable	reMarkable AS
+renesas	Renesas Electronics Corporation
+rex	iMX6 Rex Project
+rervision	Shenzhen Rervision Technology Co., Ltd.
+revotics	Revolution Robotics, Inc. (Revotics)
+richtek	Richtek Technology Corporation
+ricoh	Ricoh Co. Ltd.
+rikomagic	Rikomagic Tech Corp. Ltd
+riscv	RISC-V Foundation
+riot	Embest RIoT
+rockchip	Fuzhou Rockchip Electronics Co., Ltd
+rocktech	ROCKTECH DISPLAYS LIMITED
+rohm	ROHM Semiconductor Co., Ltd
+ronbo	Ronbo Electronics
+roofull	Shenzhen Roofull Technology Co, Ltd
+ruuvi	Ruuvi Innovations Ltd (Oy)
+roseapplepi	RoseapplePi.org
+samsung	Samsung Semiconductor
+samtec	Samtec/Softing company
+sancloud	Sancloud Ltd
+sandisk	Sandisk Corporation
+satoz	Satoz International Co., Ltd
+sbs	Smart Battery System
+schindler	Schindler
+seagate	Seagate Technology PLC
+segger	SEGGER Microcontroller GmbH
+seeed	Seeed Technology Co., Ltd
+seirobotics	Shenzhen SEI Robotics Co., Ltd
+semtech	Semtech Corporation
+sensirion	Sensirion AG
+sensortek	Sensortek Technology Corporation
+sff	Small Form Factor Committee
+sgd	Solomon Goldentek Display Corporation
+sgmicro	SG Micro Corp
+sgx	SGX Sensortech
+sharp	Sharp Corporation
+shimafuji	Shimafuji Electric, Inc.
+shiratech	Shiratech Solutions
+si-en	Si-En Technology Ltd.
+si-linux	Silicon Linux Corporation
+sifive	SiFive, Inc.
+sigma	Sigma Designs, Inc.
+sii	Seiko Instruments, Inc.
+sil	Silicon Image
+silabs	Silicon Laboratories
+silead	Silead Inc.
+silergy	Silergy Corp.
+silex-insight	Silex Insight
+siliconfile	Siliconfile Technologies lnc.
+siliconmitus	Silicon Mitus, Inc.
+siemens	Siemens AG
+simtek	Cypress Semiconductor Corporation (Simtek Corporation)
+sinlinx	Sinlinx Electronics Technology Co., LTD
+sinovoip	SinoVoip Co., Ltd
+sipeed	Shenzhen Sipeed Technology Co., Ltd.
+sirf	SiRF Technology, Inc.
+sis	Silicon Integrated Systems Corp.
+sitronix	Sitronix Technology Corporation
+skyworks	Skyworks Solutions, Inc.
+smartlabs	SmartLabs LLC
+smsc	Standard Microsystems Corporation
+snps	Synopsys, Inc.
+sochip	Shenzhen SoChip Technology Co., Ltd.
+socionext	Socionext Inc.
+solidrun	SolidRun
+solomon	Solomon Systech Limited
+sony	Sony Corporation
+spansion	Spansion Inc.
+sprd	Spreadtrum Communications Inc.
+sst	Silicon Storage Technology, Inc.
+sstar	Xiamen Xingchen(SigmaStar) Technology Co., Ltd. (formerly part of MStar Semiconductor, Inc.)
+st	STMicroelectronics
+starry	Starry Electronic Technology (ShenZhen) Co., LTD
+startek	Startek
+ste	ST-Ericsson
+stericsson	ST-Ericsson
+st-ericsson	ST-Ericsson
+summit	Summit microelectronics
+sunchip	Shenzhen Sunchip Technology Co., Ltd
+SUNW	Sun Microsystems, Inc
+supermicro	Super Micro Computer, Inc.
+silvaco	Silvaco, Inc.
+swir	Sierra Wireless
+syna	Synaptics Inc.
+synology	Synology, Inc.
+tbs	TBS Technologies
+tbs-biometrics	Touchless Biometric Systems AG
+tcg	Trusted Computing Group
+tcl	Toby Churchill Ltd.
+tcs	Shenzhen City Tang Cheng Technology Co., Ltd.
+tdo	Shangai Top Display Optoelectronics Co., Ltd
+technexion	TechNexion
+technologic	Technologic Systems
+tempo	Tempo Semiconductor
+techstar	Shenzhen Techstar Electronics Co., Ltd.
+terasic	Terasic Inc.
+tfc	Three Five Corp
+thine	THine Electronics, Inc.
+thingyjp	thingy.jp
+ti	Texas Instruments
+tianma	Tianma Micro-electronics Co., Ltd.
+tlm	Trusted Logic Mobility
+tmt	Tecon Microprocessor Technologies, LLC.
+topeet	Topeet
+toppoly	TPO (deprecated, use tpo)
+topwise	Topwise Communication Co., Ltd.
+toradex	Toradex AG
+toshiba	Toshiba Corporation
+toumaz	Toumaz
+tpk	TPK U.S.A. LLC
+tplink	TP-LINK Technologies Co., Ltd.
+tpo	TPO
+tq	TQ-Systems GmbH
+tronfy	Tronfy
+tronsmart	Tronsmart
+truly	Truly Semiconductors Limited
+visionox	Visionox
+tsd	Theobroma Systems Design und Consulting GmbH
+tyan	Tyan Computer Corporation
+u-blox	u-blox
+u-boot	U-Boot bootloader
+ucrobotics	uCRobotics
+ubnt	Ubiquiti Networks
+udoo	Udoo
+ugoos	Ugoos Industrial Co., Ltd.
+uniwest	United Western Technologies Corp (UniWest)
+upisemi	uPI Semiconductor Corp.
+urt	United Radiant Technology Corporation
+usi	Universal Scientific Industrial Co., Ltd.
+utoo	Aigo Digital Technology Co., Ltd.
+v3	V3 Semiconductor
+vaisala	Vaisala
+vamrs	Vamrs Ltd.
+variscite	Variscite Ltd.
+vdl	Van der Laan b.v.
+via	VIA Technologies, Inc.
+videostrong	Videostrong Technology Co., Ltd.
+virtio	Virtual I/O Device Specification, developed by the OASIS consortium
+virtual	Used for virtual device without specific vendor.
+vishay	Vishay Intertechnology, Inc
+vitesse	Vitesse Semiconductor Corporation
+vivante	Vivante Corporation
+vnd	A stand-in for a real vendor which can be used in examples and tests
+vocore	VoCore Studio
+voipac	Voipac Technologies s.r.o.
+vot	Vision Optical Technology Co., Ltd.
+vxt	VXT Ltd
+wand	Wandbord (Technexion)
+waveshare	Waveshare Electronics
+wd	Western Digital Corp.
+we	Würth Elektronik GmbH.
+weact	WeAct Studio
+wetek	WeTek Electronics, limited.
+wexler	Wexler
+whwave	Shenzhen whwave Electronics, Inc.
+wi2wi	Wi2Wi, Inc.
+winbond	Winbond Electronics corp.
+winstar	Winstar Display Corp.
+wits	Shenzhen Merrii Technology Co., Ltd. (WITS)
+wlf	Wolfson Microelectronics
+wm	Wondermedia Technologies, Inc.
+wobo	Wobo
+x-powers	X-Powers
+xes	Extreme Engineering Solutions (X-ES)
+xiaomi	Xiaomi Technology Co., Ltd.
+xillybus	Xillybus Ltd.
+xingbangda	Shenzhen Xingbangda Display Technology Co., Ltd
+xinpeng	Shenzhen Xinpeng Technology Co., Ltd
+xiphera	Xiphera Ltd.
+xlnx	Xilinx
+xnano	Xnano
+xunlong	Shenzhen Xunlong Software CO.,Limited
+xylon	Xylon
+yamaha	Yamaha Corporation
+yes-optoelectronics	Yes Optoelectronics Co.,Ltd.
+yic	YIC System Co., Ltd.
+ylm	Shenzhen Yangliming Electronic Technology Co., Ltd.
+yna	YSH & ATIL
+yones-toptech	Yones Toptech Co., Ltd.
+ys	Shenzhen Yashi Changhua Intelligent Technology Co., Ltd.
+ysoft	Y Soft Corporation a.s.
+zealz	Zealz
+zarlink	Zarlink Semiconductor
+zeitec	ZEITEC Semiconductor Co., LTD.
+zephyr	Zephyr-specific binding
+zidoo	Shenzhen Zidoo Technology Co., Ltd.
+zii	Zodiac Inflight Innovations
+zinitix	Zinitix Co., Ltd
+zkmagic	Shenzhen Zkmagic Technology Co., Ltd.
+zte	ZTE Corp.
+zyxel	ZyXEL Communications Corp.
diff --git a/dts/include/base.dtsi b/dts/include/base.dtsi
new file mode 100644
index 0000000000000000000000000000000000000000..b409a2fd0530f1b7700b34c9a82b4b0898d36f62
--- /dev/null
+++ b/dts/include/base.dtsi
@@ -0,0 +1,20 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2021, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+/* base level common device tree include */
+
+/* include the framework common bindings */
+#include "fwk_dt_bindings.h"
+
+
+/dts-v1/;
+/ {
+	#address-cells = <1>;
+	#size-cells = <1>;
+	chosen { };
+	aliases { };
+};
diff --git a/dts/misc/empty_file.c b/dts/misc/empty_file.c
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/dts/src/juno-scp-base.dtsi b/dts/src/juno-scp-base.dtsi
new file mode 100644
index 0000000000000000000000000000000000000000..8de9f166c764cbd566d6ee3dba75927e48e65219
--- /dev/null
+++ b/dts/src/juno-scp-base.dtsi
@@ -0,0 +1,51 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2021, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+/* base SCP .dtsi file for juno boards */
+
+/* must be first include */
+#include "base.dtsi"
+
+#include "juno_dt_bindings.h"
+
+
+/ {
+    soc {
+	    #address-cells = <1>;
+	    #size-cells = <1>;
+
+        /* main console uart */
+       	uart1: uart@BC0A0000 {
+        	compatible = "arm,pl011";
+			reg = <FPGA_UART1_BASE 0x1000>;
+            current-speed = <115200>;
+            clock-frequency = <24000000>;
+            pd-id = <POWER_DOMAIN_IDX_SYSTOP>;
+/*			clocks = <&uartclk>;*/
+/*			interrupts = <7 3>; */
+/*			interrupt-names = "rx"; */
+			label = "UART1";
+	    };
+
+
+/* another uart to validate generating arrays of elements */
+        /* main console uart */
+       	uart0: uart@BC0B0000 {
+        	compatible = "arm,pl011";
+			reg = <0xBC0b0000 0x1000>;
+            current-speed = <115200>;
+            clock-frequency = <24000000>;
+            pd-id = <POWER_DOMAIN_IDX_SYSTOP>;
+/*			clocks = <&uartclk>;*/
+/*			interrupts = <7 3>; */
+/*			interrupt-names = "rx"; */
+            label = "UART0";
+	    };
+
+
+    };
+};
\ No newline at end of file
diff --git a/framework/CMakeLists.txt b/framework/CMakeLists.txt
index b7e6b0250d62b4a18c3bd09738eac8ebdd7d8a56..a090a4f24547382efa7d10f5164a71469b264b7f 100644
--- a/framework/CMakeLists.txt
+++ b/framework/CMakeLists.txt
@@ -137,9 +137,36 @@ foreach(idx RANGE ${SCP_MODULE_IDX_MAX})
     string(APPEND SCP_MODULE_ID_CONST_GEN "static const fwk_id_t fwk_module_id_${SCP_MODULE} = FWK_MODULE_ID_${SCP_MODULE_UPPER}_INIT;\n")
 
     string(APPEND SCP_MODULE_EXTERN_GEN "extern const struct fwk_module module_${SCP_MODULE};\n")
-    string(APPEND SCP_MODULE_EXTERN_CONFIG_GEN "extern const struct fwk_module_config config_${SCP_MODULE};\n")
+
+    # generate dt binding indexes for all modules - allow for x/ref between dt and none dt configured
+    string(APPEND SCP_MODULE_DT_BINDING_IDX "#define  FWK_MODULE_IDX_${SCP_MODULE_UPPER} ${idx}\n")
+
+
+    # configuration depends if a module is in one of the DT configured lists 
+    if(SCP_MODULE IN_LIST SCP_DT_CONFIG_MODULES_ALL)
+
+        # common dt module - or platform specific with no dynamic updates
+        string(APPEND SCP_MODULE_EXTERN_CONFIG_GEN "extern const struct fwk_module_config config_dt_${SCP_MODULE};\n")
+        string(APPEND SCP_MODULE_CONFIG_GEN "    &config_dt_${SCP_MODULE},\n")
+
+        if(SCP_MODULE IN_LIST SCP_DT_CONFIG_MODULES_DYN)
+   
+           # dynamic dt config needs additional stuff
+           string(APPEND SCP_MODULE_DT_DYN_CONFIG "#define FWK_MODULE_GEN_DYNAMIC_${SCP_MODULE_UPPER}\n")
+           string(APPEND SCP_MODULE_DT_DYN_CONFIG "extern const struct fwk_element *dyn_get_element_table_${SCP_MODULE}(fwk_id_t module_id);\n")
+           string(APPEND SCP_MODULE_DT_DYN_CONFIG "extern const struct fwk_element *_static_get_element_table_${SCP_MODULE}();\n\n")
+           
+       endif()
+       
+    else()
+
+        # standard module configuration
+        string(APPEND SCP_MODULE_EXTERN_CONFIG_GEN "extern const struct fwk_module_config config_${SCP_MODULE};\n")
+        string(APPEND SCP_MODULE_CONFIG_GEN "    &config_${SCP_MODULE},\n")
+        
+    endif()
+        
     string(APPEND SCP_MODULE_GEN "    &module_${SCP_MODULE},\n")
-    string(APPEND SCP_MODULE_CONFIG_GEN "    &config_${SCP_MODULE},\n")
 
     # cmake-format: on
 
@@ -157,6 +184,13 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/include/fwk_module_idx.h.in"
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/fwk_module_list.c.in"
                "${CMAKE_CURRENT_BINARY_DIR}/src/fwk_module_list.c")
 
+# configure device tree related includes
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/include/fwk_dt_config_dyn.h.in"
+               "${CMAKE_CURRENT_BINARY_DIR}/include/fwk_dt_config_dyn.h")
+
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/include/fwk_dt_bindings_gen.h.in"
+               "${CMAKE_CURRENT_BINARY_DIR}/include/fwk_dt_bindings_gen.h")
+
 target_include_directories(framework
                            PUBLIC "${CMAKE_CURRENT_BINARY_DIR}/include")
 
diff --git a/framework/include/dt_sys/util.h b/framework/include/dt_sys/util.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c3017fe2ef3db2203ec479498be45d83003cbaf
--- /dev/null
+++ b/framework/include/dt_sys/util.h
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2011-2014, Wind River Systems, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file
+ * @brief Misc utilities
+ *
+ * Misc utilities usable by the kernel and application code.
+ */
+
+#ifndef ZEPHYR_INCLUDE_SYS_UTIL_H_
+#define ZEPHYR_INCLUDE_SYS_UTIL_H_
+
+#include <dt_sys/util_macro.h>
+
+/* needs to be outside _ASMLANGUAGE so 'true' and 'false' can turn
+ * into '1' and '0' for asm or linker scripts
+ */
+#include <stdbool.h>
+
+#ifndef _ASMLANGUAGE
+
+//#include <zephyr/types.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup sys-util Utility Functions
+ * @{
+ */
+
+/** @brief Cast @p x, a pointer, to an unsigned integer. */
+#define POINTER_TO_UINT(x) ((uintptr_t) (x))
+/** @brief Cast @p x, an unsigned integer, to a <tt>void*</tt>. */
+#define UINT_TO_POINTER(x) ((void *) (uintptr_t) (x))
+/** @brief Cast @p x, a pointer, to a signed integer. */
+#define POINTER_TO_INT(x)  ((intptr_t) (x))
+/** @brief Cast @p x, a signed integer, to a <tt>void*</tt>. */
+#define INT_TO_POINTER(x)  ((void *) (intptr_t) (x))
+
+#if !(defined(__CHAR_BIT__) && defined(__SIZEOF_LONG__))
+#	error Missing required predefined macros for BITS_PER_LONG calculation
+#endif
+
+/** Number of bits in a long int. */
+#define BITS_PER_LONG	(__CHAR_BIT__ * __SIZEOF_LONG__)
+
+/**
+ * @brief Create a contiguous bitmask starting at bit position @p l
+ *        and ending at position @p h.
+ */
+#define GENMASK(h, l) \
+	(((~0UL) - (1UL << (l)) + 1) & (~0UL >> (BITS_PER_LONG - 1 - (h))))
+
+/** @brief 0 if @p cond is true-ish; causes a compile error otherwise. */
+#define ZERO_OR_COMPILE_ERROR(cond) ((int) sizeof(char[1 - 2 * !(cond)]) - 1)
+
+#if defined(__cplusplus)
+
+/* The built-in function used below for type checking in C is not
+ * supported by GNU C++.
+ */
+#define ARRAY_SIZE(array) (sizeof(array) / sizeof((array)[0]))
+
+#else /* __cplusplus */
+
+/**
+ * @brief Zero if @p array has an array type, a compile error otherwise
+ *
+ * This macro is available only from C, not C++.
+ */
+#define IS_ARRAY(array) \
+	ZERO_OR_COMPILE_ERROR( \
+		!__builtin_types_compatible_p(__typeof__(array), \
+					      __typeof__(&(array)[0])))
+
+/**
+ * @brief Number of elements in the given @p array
+ *
+ * In C++, due to language limitations, this will accept as @p array
+ * any type that implements <tt>operator[]</tt>. The results may not be
+ * particulary meaningful in this case.
+ *
+ * In C, passing a pointer as @p array causes a compile error.
+ */
+#define ARRAY_SIZE(array) \
+	((long) (IS_ARRAY(array) + (sizeof(array) / sizeof((array)[0]))))
+
+#endif /* __cplusplus */
+
+/**
+ * @brief Check if a pointer @p ptr lies within @p array.
+ *
+ * In C but not C++, this causes a compile error if @p array is not an array
+ * (e.g. if @p ptr and @p array are mixed up).
+ *
+ * @param ptr a pointer
+ * @param array an array
+ * @return 1 if @p ptr is part of @p array, 0 otherwise
+ */
+#define PART_OF_ARRAY(array, ptr) \
+	((ptr) && ((ptr) >= &array[0] && (ptr) < &array[ARRAY_SIZE(array)]))
+
+/**
+ * @brief Get a pointer to a container structure from an element
+ *
+ * Example:
+ *
+ *	struct foo {
+ *		int bar;
+ *	};
+ *
+ *	struct foo my_foo;
+ *	int *ptr = &my_foo.bar;
+ *
+ *	struct foo *container = CONTAINER_OF(ptr, struct foo, bar);
+ *
+ * Above, @p container points at @p my_foo.
+ *
+ * @param ptr pointer to a structure element
+ * @param type name of the type that @p ptr is an element of
+ * @param field the name of the field within the struct @p ptr points to
+ * @return a pointer to the structure that contains @p ptr
+ */
+#define CONTAINER_OF(ptr, type, field) \
+	((type *)(((char *)(ptr)) - offsetof(type, field)))
+
+/**
+ * @brief Value of @p x rounded up to the next multiple of @p align,
+ *        which must be a power of 2.
+ */
+#define ROUND_UP(x, align)                                   \
+	(((unsigned long)(x) + ((unsigned long)(align) - 1)) & \
+	 ~((unsigned long)(align) - 1))
+
+/**
+ * @brief Value of @p x rounded down to the previous multiple of @p
+ *        align, which must be a power of 2.
+ */
+#define ROUND_DOWN(x, align)                                 \
+	((unsigned long)(x) & ~((unsigned long)(align) - 1))
+
+/** @brief Value of @p x rounded up to the next word boundary. */
+#define WB_UP(x) ROUND_UP(x, sizeof(void *))
+
+/** @brief Value of @p x rounded down to the previous word boundary. */
+#define WB_DN(x) ROUND_DOWN(x, sizeof(void *))
+
+/**
+ * @brief Ceiling function applied to @p numerator / @p divider as a fraction.
+ */
+#define ceiling_fraction(numerator, divider) \
+	(((numerator) + ((divider) - 1)) / (divider))
+
+/**
+ * @def MAX
+ * @brief The larger value between @p a and @p b.
+ * @note Arguments are evaluated twice.
+ */
+#ifndef MAX
+/* Use Z_MAX for a GCC-only, single evaluation version */
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+#endif
+
+/**
+ * @def MIN
+ * @brief The smaller value between @p a and @p b.
+ * @note Arguments are evaluated twice.
+ */
+#ifndef MIN
+/* Use Z_MIN for a GCC-only, single evaluation version */
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#endif
+
+/**
+ * @def CLAMP
+ * @brief Clamp a value to a given range.
+ * @note Arguments are evaluated multiple times.
+ */
+#ifndef CLAMP
+/* Use Z_CLAMP for a GCC-only, single evaluation version */
+#define CLAMP(val, low, high) (((val) <= (low)) ? (low) : MIN(val, high))
+#endif
+
+/**
+ * @brief Is @p x a power of two?
+ * @param x value to check
+ * @return true if @p x is a power of two, false otherwise
+ */
+static inline bool is_power_of_two(unsigned int x)
+{
+	return (x != 0U) && ((x & (x - 1U)) == 0U);
+}
+
+/**
+ * @brief Arithmetic shift right
+ * @param value value to shift
+ * @param shift number of bits to shift
+ * @return @p value shifted right by @p shift; opened bit positions are
+ *         filled with the sign bit
+ */
+static inline int64_t arithmetic_shift_right(int64_t value, uint8_t shift)
+{
+	int64_t sign_ext;
+
+	if (shift == 0U) {
+		return value;
+	}
+
+	/* extract sign bit */
+	sign_ext = (value >> 63) & 1;
+
+	/* make all bits of sign_ext be the same as the value's sign bit */
+	sign_ext = -sign_ext;
+
+	/* shift value and fill opened bit positions with sign bit */
+	return (value >> shift) | (sign_ext << (64 - shift));
+}
+
+/**
+ * @brief byte by byte memcpy.
+ *
+ * Copy `size` bytes of `src` into `dest`. This is guaranteed to be done byte by byte.
+ *
+ * @param dst Pointer to the destination memory.
+ * @param src Pointer to the source of the data.
+ * @param size The number of bytes to copy.
+ */
+static inline void bytecpy(void *dst, const void *src, size_t size)
+{
+	size_t i;
+
+	for (i = 0; i < size; ++i) {
+		((uint8_t *)dst)[i] = ((uint8_t *)src)[i];
+	}
+}
+
+/**
+ * @brief      Convert a single character into a hexadecimal nibble.
+ *
+ * @param c     The character to convert
+ * @param x     The address of storage for the converted number.
+ *
+ *  @return Zero on success or (negative) error code otherwise.
+ */
+int char2hex(char c, uint8_t *x);
+
+/**
+ * @brief      Convert a single hexadecimal nibble into a character.
+ *
+ * @param c     The number to convert
+ * @param x     The address of storage for the converted character.
+ *
+ *  @return Zero on success or (negative) error code otherwise.
+ */
+int hex2char(uint8_t x, char *c);
+
+/**
+ * @brief      Convert a binary array into string representation.
+ *
+ * @param buf     The binary array to convert
+ * @param buflen  The length of the binary array to convert
+ * @param hex     Address of where to store the string representation.
+ * @param hexlen  Size of the storage area for string representation.
+ *
+ * @return     The length of the converted string, or 0 if an error occurred.
+ */
+size_t bin2hex(const uint8_t *buf, size_t buflen, char *hex, size_t hexlen);
+
+/**
+ * @brief      Convert a hexadecimal string into a binary array.
+ *
+ * @param hex     The hexadecimal string to convert
+ * @param hexlen  The length of the hexadecimal string to convert.
+ * @param buf     Address of where to store the binary data
+ * @param buflen  Size of the storage area for binary data
+ *
+ * @return     The length of the binary array, or 0 if an error occurred.
+ */
+size_t hex2bin(const char *hex, size_t hexlen, uint8_t *buf, size_t buflen);
+
+/**
+ * @brief      Convert a uint8_t into a decimal string representation.
+ *
+ * Convert a uint8_t value into its ASCII decimal string representation.
+ * The string is terminated if there is enough space in buf.
+ *
+ * @param buf     Address of where to store the string representation.
+ * @param buflen  Size of the storage area for string representation.
+ * @param value   The value to convert to decimal string
+ *
+ * @return     The length of the converted string (excluding terminator if
+ *             any), or 0 if an error occurred.
+ */
+uint8_t u8_to_dec(char *buf, uint8_t buflen, uint8_t value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_ASMLANGUAGE */
+
+/** @brief Number of bytes in @p x kibibytes */
+#ifdef _LINKER
+/* This is used in linker scripts so need to avoid type casting there */
+#define KB(x) ((x) << 10)
+#else
+#define KB(x) (((size_t)x) << 10)
+#endif
+/** @brief Number of bytes in @p x mebibytes */
+#define MB(x) (KB(x) << 10)
+/** @brief Number of bytes in @p x gibibytes */
+#define GB(x) (MB(x) << 10)
+
+/** @brief Number of Hz in @p x kHz */
+#define KHZ(x) ((x) * 1000)
+/** @brief Number of Hz in @p x MHz */
+#define MHZ(x) (KHZ(x) * 1000)
+
+/**
+ * @}
+ */
+
+#endif /* ZEPHYR_INCLUDE_SYS_UTIL_H_ */
diff --git a/framework/include/dt_sys/util_internal.h b/framework/include/dt_sys/util_internal.h
new file mode 100644
index 0000000000000000000000000000000000000000..3b70ec3deb732f2c8f68165bd89455c1b69c3250
--- /dev/null
+++ b/framework/include/dt_sys/util_internal.h
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2011-2014, Wind River Systems, Inc.
+ * Copyright (c) 2020, Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file
+ * @brief Misc utilities
+ *
+ * Repetitive or obscure helper macros needed by sys/util.h.
+ */
+
+#ifndef ZEPHYR_INCLUDE_SYS_UTIL_INTERNAL_H_
+#define ZEPHYR_INCLUDE_SYS_UTIL_INTERNAL_H_
+
+#include "util_loops.h"
+
+/* IS_ENABLED() helpers */
+
+/* This is called from IS_ENABLED(), and sticks on a "_XXXX" prefix,
+ * it will now be "_XXXX1" if config_macro is "1", or just "_XXXX" if it's
+ * undefined.
+ *   ENABLED:   Z_IS_ENABLED2(_XXXX1)
+ *   DISABLED   Z_IS_ENABLED2(_XXXX)
+ */
+#define Z_IS_ENABLED1(config_macro) Z_IS_ENABLED2(_XXXX##config_macro)
+
+/* Here's the core trick, we map "_XXXX1" to "_YYYY," (i.e. a string
+ * with a trailing comma), so it has the effect of making this a
+ * two-argument tuple to the preprocessor only in the case where the
+ * value is defined to "1"
+ *   ENABLED:    _YYYY,    <--- note comma!
+ *   DISABLED:   _XXXX
+ */
+#define _XXXX1 _YYYY,
+
+/* Then we append an extra argument to fool the gcc preprocessor into
+ * accepting it as a varargs macro.
+ *                         arg1   arg2  arg3
+ *   ENABLED:   Z_IS_ENABLED3(_YYYY,    1,    0)
+ *   DISABLED   Z_IS_ENABLED3(_XXXX 1,  0)
+ */
+#define Z_IS_ENABLED2(one_or_two_args) Z_IS_ENABLED3(one_or_two_args 1, 0)
+
+/* And our second argument is thus now cooked to be 1 in the case
+ * where the value is defined to 1, and 0 if not:
+ */
+#define Z_IS_ENABLED3(ignore_this, val, ...) val
+
+/* Used internally by COND_CODE_1 and COND_CODE_0. */
+#define Z_COND_CODE_1(_flag, _if_1_code, _else_code) \
+	__COND_CODE(_XXXX##_flag, _if_1_code, _else_code)
+#define Z_COND_CODE_0(_flag, _if_0_code, _else_code) \
+	__COND_CODE(_ZZZZ##_flag, _if_0_code, _else_code)
+#define _ZZZZ0 _YYYY,
+#define __COND_CODE(one_or_two_args, _if_code, _else_code) \
+	__GET_ARG2_DEBRACKET(one_or_two_args _if_code, _else_code)
+
+/* Gets second argument and removes brackets around that argument. It
+ * is expected that the parameter is provided in brackets/parentheses.
+ */
+#define __GET_ARG2_DEBRACKET(ignore_this, val, ...) __DEBRACKET val
+
+/* Used to remove brackets from around a single argument. */
+#define __DEBRACKET(...) __VA_ARGS__
+
+/* Used by IS_EMPTY() */
+#define Z_IS_EMPTY_(...) Z_IS_EMPTY__(__VA_ARGS__)
+#define Z_IS_EMPTY__(a, ...) Z_IS_EMPTY___(_ZZ##a##ZZ0, __VA_ARGS__)
+#define Z_IS_EMPTY___(...) GET_ARG_N(3, __VA_ARGS__)
+
+/* Used by LIST_DROP_EMPTY() */
+/* Adding ',' after each element would add empty element at the end of
+ * list, which is hard to remove, so instead precede each element with ',',
+ * this way first element is empty, and this one is easy to drop.
+ */
+#define Z_LIST_ADD_ELEM(e) EMPTY, e
+#define Z_LIST_DROP_FIRST(...) GET_ARGS_LESS_N(1, __VA_ARGS__)
+#define Z_LIST_NO_EMPTIES(e) \
+	COND_CODE_1(IS_EMPTY(e), (), (Z_LIST_ADD_ELEM(e)))
+
+#define UTIL_CAT(a, ...) UTIL_PRIMITIVE_CAT(a, __VA_ARGS__)
+#define UTIL_PRIMITIVE_CAT(a, ...) a##__VA_ARGS__
+#define UTIL_CHECK_N(x, n, ...) n
+#define UTIL_CHECK(...) UTIL_CHECK_N(__VA_ARGS__, 0,)
+#define UTIL_NOT(x) UTIL_CHECK(UTIL_PRIMITIVE_CAT(UTIL_NOT_, x))
+#define UTIL_NOT_0 ~, 1,
+#define UTIL_COMPL(b) UTIL_PRIMITIVE_CAT(UTIL_COMPL_, b)
+#define UTIL_COMPL_0 1
+#define UTIL_COMPL_1 0
+#define UTIL_BOOL(x) UTIL_COMPL(UTIL_NOT(x))
+
+#define UTIL_EVAL(...) __VA_ARGS__
+#define UTIL_EXPAND(...) __VA_ARGS__
+#define UTIL_REPEAT(...) UTIL_LISTIFY(__VA_ARGS__)
+
+/* Implementation details for NUM_VA_ARGS_LESS_1 */
+#define NUM_VA_ARGS_LESS_1_IMPL(				\
+	_ignored,						\
+	_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10,		\
+	_11, _12, _13, _14, _15, _16, _17, _18, _19, _20,	\
+	_21, _22, _23, _24, _25, _26, _27, _28, _29, _30,	\
+	_31, _32, _33, _34, _35, _36, _37, _38, _39, _40,	\
+	_41, _42, _43, _44, _45, _46, _47, _48, _49, _50,	\
+	_51, _52, _53, _54, _55, _56, _57, _58, _59, _60,	\
+	_61, _62, N, ...) N
+
+/* Used by MACRO_MAP_CAT */
+#define MACRO_MAP_CAT_(...)						\
+	/* To make sure it works also for 2 arguments in total */	\
+	MACRO_MAP_CAT_N(NUM_VA_ARGS_LESS_1(__VA_ARGS__), __VA_ARGS__)
+#define MACRO_MAP_CAT_N_(N, ...) UTIL_CAT(MACRO_MC_, N)(__VA_ARGS__,)
+#define MACRO_MC_0(...)
+#define MACRO_MC_1(m, a, ...)  m(a)
+#define MACRO_MC_2(m, a, ...)  UTIL_CAT(m(a), MACRO_MC_1(m, __VA_ARGS__,))
+#define MACRO_MC_3(m, a, ...)  UTIL_CAT(m(a), MACRO_MC_2(m, __VA_ARGS__,))
+#define MACRO_MC_4(m, a, ...)  UTIL_CAT(m(a), MACRO_MC_3(m, __VA_ARGS__,))
+#define MACRO_MC_5(m, a, ...)  UTIL_CAT(m(a), MACRO_MC_4(m, __VA_ARGS__,))
+#define MACRO_MC_6(m, a, ...)  UTIL_CAT(m(a), MACRO_MC_5(m, __VA_ARGS__,))
+#define MACRO_MC_7(m, a, ...)  UTIL_CAT(m(a), MACRO_MC_6(m, __VA_ARGS__,))
+#define MACRO_MC_8(m, a, ...)  UTIL_CAT(m(a), MACRO_MC_7(m, __VA_ARGS__,))
+#define MACRO_MC_9(m, a, ...)  UTIL_CAT(m(a), MACRO_MC_8(m, __VA_ARGS__,))
+#define MACRO_MC_10(m, a, ...) UTIL_CAT(m(a), MACRO_MC_9(m, __VA_ARGS__,))
+#define MACRO_MC_11(m, a, ...) UTIL_CAT(m(a), MACRO_MC_10(m, __VA_ARGS__,))
+#define MACRO_MC_12(m, a, ...) UTIL_CAT(m(a), MACRO_MC_11(m, __VA_ARGS__,))
+#define MACRO_MC_13(m, a, ...) UTIL_CAT(m(a), MACRO_MC_12(m, __VA_ARGS__,))
+#define MACRO_MC_14(m, a, ...) UTIL_CAT(m(a), MACRO_MC_13(m, __VA_ARGS__,))
+#define MACRO_MC_15(m, a, ...) UTIL_CAT(m(a), MACRO_MC_14(m, __VA_ARGS__,))
+
+#endif /* ZEPHYR_INCLUDE_SYS_UTIL_INTERNAL_H_ */
diff --git a/framework/include/dt_sys/util_loops.h b/framework/include/dt_sys/util_loops.h
new file mode 100644
index 0000000000000000000000000000000000000000..7b2e1281ec6a3a37f845a91e3067f2a8920db4b1
--- /dev/null
+++ b/framework/include/dt_sys/util_loops.h
@@ -0,0 +1,2108 @@
+/*
+ * Copyright (c) 2021, Nordic Semiconductor ASA
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file
+ * @brief Internals for looping macros
+ *
+ * Repetitive or obscure helper macros needed by sys/util.h.
+ */
+
+#ifndef ZEPHYR_INCLUDE_SYS_UTIL_LOOPS_H_
+#define ZEPHYR_INCLUDE_SYS_UTIL_LOOPS_H_
+
+#define Z_FOR_LOOP_GET_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, \
+				_12, _13, _14, _15, _16, _17, _18, _19, _20, \
+				_21, _22, _23, _24, _25, _26, _27, _28, _29, \
+				_30, _31, _32, _33, _34, _35, _36, _37, _38, \
+				_39, _40, _41, _42, _43, _44, _45, _46, _47, \
+				_48, _49, _50, _51, _52, _53, _54, _55, _56, \
+				_57, _58, _59, _60, _61, _62, _63, _64, N, ...) N
+
+#define Z_FOR_LOOP_0(z_call, sep, fixed_arg0, fixed_arg1, ...)
+
+#define Z_FOR_LOOP_1(z_call, sep, fixed_arg0, fixed_arg1, x) \
+	z_call(0, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_2(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_1(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(1, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_3(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_2(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(2, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_4(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_3(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(3, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_5(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_4(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(4, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_6(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_5(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(5, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_7(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_6(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(6, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_8(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_7(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(7, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_9(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_8(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(8, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_10(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_9(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(9, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_11(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_10(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(10, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_12(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_11(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(11, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_13(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_12(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(12, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_14(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_13(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(13, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_15(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_14(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(14, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_16(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_15(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(15, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_17(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_16(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(16, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_18(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_17(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(17, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_19(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_18(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(18, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_20(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_19(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(19, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_21(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_20(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(20, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_22(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_21(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(21, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_23(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_22(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(22, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_24(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_23(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(23, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_25(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_24(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(24, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_26(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_25(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(25, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_27(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_26(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(26, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_28(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_27(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(27, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_29(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_28(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(28, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_30(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_29(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(29, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_31(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_30(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(30, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_32(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_31(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(31, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_33(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_32(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(32, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_34(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_33(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(33, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_35(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_34(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(34, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_36(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_35(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(35, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_37(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_36(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(36, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_38(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_37(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(37, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_39(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_38(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(38, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_40(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_39(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(39, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_41(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_40(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(40, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_42(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_41(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(41, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_43(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_42(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(42, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_44(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_43(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(43, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_45(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_44(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(44, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_46(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_45(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(45, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_47(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_46(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(46, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_48(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_47(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(47, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_49(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_48(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(48, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_50(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_49(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(49, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_51(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_50(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(50, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_52(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_51(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(51, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_53(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_52(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(52, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_54(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_53(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(53, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_55(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_54(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(54, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_56(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_55(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(55, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_57(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_56(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(56, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_58(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_57(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(57, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_59(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_58(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(58, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_60(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_59(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(59, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_61(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_60(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(60, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_62(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_61(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(61, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_63(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_62(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(62, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_LOOP_64(z_call, sep, fixed_arg0, fixed_arg1, x, ...) \
+	Z_FOR_LOOP_63(z_call, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__) \
+	__DEBRACKET sep \
+	z_call(63, x, fixed_arg0, fixed_arg1)
+
+#define Z_FOR_EACH_ENGINE(x, sep, fixed_arg0, fixed_arg1, ...) \
+	Z_FOR_LOOP_GET_ARG(__VA_ARGS__, \
+		Z_FOR_LOOP_64, \
+		Z_FOR_LOOP_63, \
+		Z_FOR_LOOP_62, \
+		Z_FOR_LOOP_61, \
+		Z_FOR_LOOP_60, \
+		Z_FOR_LOOP_59, \
+		Z_FOR_LOOP_58, \
+		Z_FOR_LOOP_57, \
+		Z_FOR_LOOP_56, \
+		Z_FOR_LOOP_55, \
+		Z_FOR_LOOP_54, \
+		Z_FOR_LOOP_53, \
+		Z_FOR_LOOP_52, \
+		Z_FOR_LOOP_51, \
+		Z_FOR_LOOP_50, \
+		Z_FOR_LOOP_49, \
+		Z_FOR_LOOP_48, \
+		Z_FOR_LOOP_47, \
+		Z_FOR_LOOP_46, \
+		Z_FOR_LOOP_45, \
+		Z_FOR_LOOP_44, \
+		Z_FOR_LOOP_43, \
+		Z_FOR_LOOP_42, \
+		Z_FOR_LOOP_41, \
+		Z_FOR_LOOP_40, \
+		Z_FOR_LOOP_39, \
+		Z_FOR_LOOP_38, \
+		Z_FOR_LOOP_37, \
+		Z_FOR_LOOP_36, \
+		Z_FOR_LOOP_35, \
+		Z_FOR_LOOP_34, \
+		Z_FOR_LOOP_33, \
+		Z_FOR_LOOP_32, \
+		Z_FOR_LOOP_31, \
+		Z_FOR_LOOP_30, \
+		Z_FOR_LOOP_29, \
+		Z_FOR_LOOP_28, \
+		Z_FOR_LOOP_27, \
+		Z_FOR_LOOP_26, \
+		Z_FOR_LOOP_25, \
+		Z_FOR_LOOP_24, \
+		Z_FOR_LOOP_23, \
+		Z_FOR_LOOP_22, \
+		Z_FOR_LOOP_21, \
+		Z_FOR_LOOP_20, \
+		Z_FOR_LOOP_19, \
+		Z_FOR_LOOP_18, \
+		Z_FOR_LOOP_17, \
+		Z_FOR_LOOP_16, \
+		Z_FOR_LOOP_15, \
+		Z_FOR_LOOP_14, \
+		Z_FOR_LOOP_13, \
+		Z_FOR_LOOP_12, \
+		Z_FOR_LOOP_11, \
+		Z_FOR_LOOP_10, \
+		Z_FOR_LOOP_9, \
+		Z_FOR_LOOP_8, \
+		Z_FOR_LOOP_7, \
+		Z_FOR_LOOP_6, \
+		Z_FOR_LOOP_5, \
+		Z_FOR_LOOP_4, \
+		Z_FOR_LOOP_3, \
+		Z_FOR_LOOP_2, \
+		Z_FOR_LOOP_1, \
+		Z_FOR_LOOP_0)(x, sep, fixed_arg0, fixed_arg1, ##__VA_ARGS__)
+
+#define Z_GET_ARG_1(_0, ...) _0
+
+#define Z_GET_ARG_2(_0, _1, ...) _1
+
+#define Z_GET_ARG_3(_0, _1, _2, ...) _2
+
+#define Z_GET_ARG_4(_0, _1, _2, _3, ...) _3
+
+#define Z_GET_ARG_5(_0, _1, _2, _3, _4, ...) _4
+
+#define Z_GET_ARG_6(_0, _1, _2, _3, _4, _5, ...) _5
+
+#define Z_GET_ARG_7(_0, _1, _2, _3, _4, _5, _6, ...) _6
+
+#define Z_GET_ARG_8(_0, _1, _2, _3, _4, _5, _6, _7, ...) _7
+
+#define Z_GET_ARG_9(_0, _1, _2, _3, _4, _5, _6, _7, _8, ...) _8
+
+#define Z_GET_ARG_10(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, ...) _9
+
+#define Z_GET_ARG_11(_0, _1, _2, _3, _4, _5, \
+			  _6, _7, _8, _9, _10, ...) _10
+
+#define Z_GET_ARG_12(_0, _1, _2, _3, _4, _5, _6,\
+			  _7, _8, _9, _10, _11, ...) _11
+
+#define Z_GET_ARG_13(_0, _1, _2, _3, _4, _5, _6, \
+			  _7, _8, _9, _10, _11, _12, ...) _12
+
+#define Z_GET_ARG_14(_0, _1, _2, _3, _4, _5, _6, \
+			  _7, _8, _9, _10, _11, _12, _13, ...) _13
+
+#define Z_GET_ARG_15(_0, _1, _2, _3, _4, _5, _6, _7, \
+			  _8, _9, _10, _11, _12, _13, _14, ...) _14
+
+#define Z_GET_ARG_16(_0, _1, _2, _3, _4, _5, _6, _7, \
+			  _8, _9, _10, _11, _12, _13, _14, _15, ...) _15
+
+#define Z_GET_ARG_17(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, ...) _16
+
+#define Z_GET_ARG_18(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, ...) _17
+
+#define Z_GET_ARG_19(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, ...) _18
+
+#define Z_GET_ARG_20(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  ...) _19
+
+#define Z_GET_ARG_21(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, ...) _20
+
+#define Z_GET_ARG_22(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, ...) _21
+
+#define Z_GET_ARG_23(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, ...) _22
+
+#define Z_GET_ARG_24(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, ...) _23
+
+#define Z_GET_ARG_25(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, ...) _24
+
+#define Z_GET_ARG_26(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, ...) _25
+
+#define Z_GET_ARG_27(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, ...) _26
+
+#define Z_GET_ARG_28(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, ...) _27
+
+#define Z_GET_ARG_29(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  ...) _28
+
+#define Z_GET_ARG_30(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, ...) _29
+
+#define Z_GET_ARG_31(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, ...) _30
+
+#define Z_GET_ARG_32(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, ...) _31
+
+#define Z_GET_ARG_33(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, ...) _32
+
+#define Z_GET_ARG_34(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, ...) _33
+
+#define Z_GET_ARG_35(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, ...) _34
+
+#define Z_GET_ARG_36(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, ...) _35
+
+#define Z_GET_ARG_37(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, ...) _36
+
+#define Z_GET_ARG_38(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, ...) _37
+
+#define Z_GET_ARG_39(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, ...) _38
+
+#define Z_GET_ARG_40(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, ...) _39
+
+#define Z_GET_ARG_41(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, ...) _40
+
+#define Z_GET_ARG_42(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, ...) _41
+
+#define Z_GET_ARG_43(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, ...) _42
+
+#define Z_GET_ARG_44(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, ...) _43
+
+#define Z_GET_ARG_45(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, ...) _44
+
+#define Z_GET_ARG_46(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, ...) _45
+
+#define Z_GET_ARG_47(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, ...) _46
+
+#define Z_GET_ARG_48(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, ...) _47
+
+#define Z_GET_ARG_49(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, ...) _48
+
+#define Z_GET_ARG_50(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, ...) _49
+
+#define Z_GET_ARG_51(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, ...) _50
+
+#define Z_GET_ARG_52(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, ...) _51
+
+#define Z_GET_ARG_53(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, ...) _52
+
+#define Z_GET_ARG_54(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, _53, ...) _53
+
+#define Z_GET_ARG_55(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, _53, _54, ...) _54
+
+#define Z_GET_ARG_56(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, _53, _54, _55, ...) _55
+
+#define Z_GET_ARG_57(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, _53, _54, _55, \
+			  _56, ...) _56
+
+#define Z_GET_ARG_58(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, _53, _54, _55, \
+			  _56, _57, ...) _57
+
+#define Z_GET_ARG_59(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, _53, _54, _55, \
+			  _56, _57, _58, ...) _58
+
+#define Z_GET_ARG_60(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, _53, _54, _55, \
+			  _56, _57, _58, _59, ...) _59
+
+#define Z_GET_ARG_61(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, _53, _54, _55, \
+			  _56, _57, _58, _59, _60, ...) _60
+
+#define Z_GET_ARG_62(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, _53, _54, _55, \
+			  _56, _57, _58, _59, _60, _61, ...) _61
+
+#define Z_GET_ARG_63(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, _53, _54, _55, \
+			  _56, _57, _58, _59, _60, _61, _62, ...) _62
+
+#define Z_GET_ARG_64(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+			  _11, _12, _13, _14, _15, _16, _17, _18, _19, \
+			  _20, _21, _22, _23, _24, _25, _26, _27, _28, \
+			  _29, _30, _31, _32, _33, _34, _35, _36, _37, \
+			  _38, _39, _40, _41, _42, _43, _44, _45, _46, \
+			  _47, _48, _49, _50, _51, _52, _53, _54, _55, \
+			  _56, _57, _58, _59, _60, _61, _62, _63, ...) _63
+
+#define Z_GET_ARGS_LESS_0(...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_1(_0, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_2(_0, _1, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_3(_0, _1, _2, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_4(_0, _1, _2, _3, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_5(_0, _1, _2, _3, _4, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_6(_0, _1, _2, _3, _4, _5, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_7(_0, _1, _2, _3, _4, _5, _6, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_8(_0, _1, _2, _3, _4, _5, \
+				_6, _7, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_9(_0, _1, _2, _3, _4, _5, \
+				_6, _7, _8, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_10(_0, _1, _2, _3, _4, _5, \
+				_6, _7, _8, _9, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_11(_0, _1, _2, _3, _4, _5, \
+				_6, _7, _8, _9, _10, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_12(_0, _1, _2, _3, _4, _5, _6,\
+				_7, _8, _9, _10, _11, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_13(_0, _1, _2, _3, _4, _5, _6, \
+				_7, _8, _9, _10, _11, _12, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_14(_0, _1, _2, _3, _4, _5, _6, \
+				_7, _8, _9, _10, _11, _12, _13, \
+				...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_15(_0, _1, _2, _3, _4, _5, _6, _7, \
+				_8, _9, _10, _11, _12, _13, _14, \
+				...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_16(_0, _1, _2, _3, _4, _5, _6, _7, \
+				_8, _9, _10, _11, _12, _13, _14, _15, ...) \
+				__VA_ARGS__
+
+#define Z_GET_ARGS_LESS_17(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_18(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, ...) \
+				__VA_ARGS__
+
+#define Z_GET_ARGS_LESS_19(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, ...) \
+				__VA_ARGS__
+
+#define Z_GET_ARGS_LESS_20(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_21(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_22(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_23(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_24(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_25(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_26(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_27(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, ...) \
+				__VA_ARGS__
+
+#define Z_GET_ARGS_LESS_28(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, \
+				...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_29(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_30(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_31(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_32(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_33(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_34(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_35(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_36(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_37(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_38(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_39(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_40(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_41(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_42(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_43(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_44(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_45(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_46(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_47(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_48(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_49(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_50(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_51(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_52(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_53(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_54(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, _53, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_55(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, _53, _54, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_56(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, _53, _54, _55, \
+				...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_57(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, _53, _54, _55, \
+				_56, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_58(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, _53, _54, _55, \
+				_56, _57, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_59(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, _53, _54, _55, \
+				_56, _57, _58, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_60(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, _53, _54, _55, \
+				_56, _57, _58, _59, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_61(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, _53, _54, _55, \
+				_56, _57, _58, _59, _60, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_62(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, _53, _54, _55, \
+				_56, _57, _58, _59, _60, _61, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_63(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, _53, _54, _55, \
+				_56, _57, _58, _59, _60, _61, _62, ...) __VA_ARGS__
+
+#define Z_GET_ARGS_LESS_64(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
+				_11, _12, _13, _14, _15, _16, _17, _18, _19, \
+				_20, _21, _22, _23, _24, _25, _26, _27, _28, \
+				_29, _30, _31, _32, _33, _34, _35, _36, _37, \
+				_38, _39, _40, _41, _42, _43, _44, _45, _46, \
+				_47, _48, _49, _50, _51, _52, _53, _54, _55, \
+				_56, _57, _58, _59, _60, _61, _62, _63, ...) __VA_ARGS__
+
+#define Z_FOR_EACH_IDX_FIXED_ARG_EXEC(idx, x, fixed_arg0, fixed_arg1) \
+	fixed_arg0(idx, x, fixed_arg1)
+
+#define Z_FOR_EACH_IDX_FIXED_ARG(F, sep, fixed_arg, ...) \
+	Z_FOR_EACH_ENGINE(Z_FOR_EACH_IDX_FIXED_ARG_EXEC, sep, \
+			     F, fixed_arg, __VA_ARGS__)
+
+#define Z_FOR_EACH_FIXED_ARG_EXEC(idx, x, fixed_arg0, fixed_arg1) \
+	fixed_arg0(x, fixed_arg1)
+
+#define Z_FOR_EACH_FIXED_ARG(F, sep, fixed_arg, ...) \
+	Z_FOR_EACH_ENGINE(Z_FOR_EACH_FIXED_ARG_EXEC, sep, \
+			     F, fixed_arg, __VA_ARGS__)
+
+#define Z_FOR_EACH_IDX_EXEC(idx, x, fixed_arg0, fixed_arg1) \
+	fixed_arg0(idx, x)
+
+#define Z_FOR_EACH_IDX(F, sep, ...) \
+	Z_FOR_EACH_ENGINE(Z_FOR_EACH_IDX_EXEC, sep, F, _, __VA_ARGS__)
+
+#define Z_FOR_EACH_EXEC(idx, x, fixed_arg0, fixed_arg1) \
+	fixed_arg0(x)
+
+#define Z_FOR_EACH(F, sep, ...) \
+	Z_FOR_EACH_ENGINE(Z_FOR_EACH_EXEC, sep, F, _, __VA_ARGS__)
+
+#define Z_BYPASS(x) x
+
+/* Set of UTIL_LISTIFY particles */
+#define Z_UTIL_LISTIFY_0(F, ...)
+
+#define Z_UTIL_LISTIFY_1(F, ...) \
+	F(0, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_2(F, ...) \
+	Z_UTIL_LISTIFY_1(F, __VA_ARGS__) \
+	F(1, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_3(F, ...) \
+	Z_UTIL_LISTIFY_2(F, __VA_ARGS__) \
+	F(2, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_4(F, ...) \
+	Z_UTIL_LISTIFY_3(F, __VA_ARGS__) \
+	F(3, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_5(F, ...) \
+	Z_UTIL_LISTIFY_4(F, __VA_ARGS__) \
+	F(4, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_6(F, ...) \
+	Z_UTIL_LISTIFY_5(F, __VA_ARGS__) \
+	F(5, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_7(F, ...) \
+	Z_UTIL_LISTIFY_6(F, __VA_ARGS__) \
+	F(6, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_8(F, ...) \
+	Z_UTIL_LISTIFY_7(F, __VA_ARGS__) \
+	F(7, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_9(F, ...) \
+	Z_UTIL_LISTIFY_8(F, __VA_ARGS__) \
+	F(8, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_10(F, ...) \
+	Z_UTIL_LISTIFY_9(F, __VA_ARGS__) \
+	F(9, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_11(F, ...) \
+	Z_UTIL_LISTIFY_10(F, __VA_ARGS__) \
+	F(10, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_12(F, ...) \
+	Z_UTIL_LISTIFY_11(F, __VA_ARGS__) \
+	F(11, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_13(F, ...) \
+	Z_UTIL_LISTIFY_12(F, __VA_ARGS__) \
+	F(12, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_14(F, ...) \
+	Z_UTIL_LISTIFY_13(F, __VA_ARGS__) \
+	F(13, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_15(F, ...) \
+	Z_UTIL_LISTIFY_14(F, __VA_ARGS__) \
+	F(14, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_16(F, ...) \
+	Z_UTIL_LISTIFY_15(F, __VA_ARGS__) \
+	F(15, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_17(F, ...) \
+	Z_UTIL_LISTIFY_16(F, __VA_ARGS__) \
+	F(16, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_18(F, ...) \
+	Z_UTIL_LISTIFY_17(F, __VA_ARGS__) \
+	F(17, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_19(F, ...) \
+	Z_UTIL_LISTIFY_18(F, __VA_ARGS__) \
+	F(18, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_20(F, ...) \
+	Z_UTIL_LISTIFY_19(F, __VA_ARGS__) \
+	F(19, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_21(F, ...) \
+	Z_UTIL_LISTIFY_20(F, __VA_ARGS__) \
+	F(20, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_22(F, ...) \
+	Z_UTIL_LISTIFY_21(F, __VA_ARGS__) \
+	F(21, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_23(F, ...) \
+	Z_UTIL_LISTIFY_22(F, __VA_ARGS__) \
+	F(22, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_24(F, ...) \
+	Z_UTIL_LISTIFY_23(F, __VA_ARGS__) \
+	F(23, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_25(F, ...) \
+	Z_UTIL_LISTIFY_24(F, __VA_ARGS__) \
+	F(24, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_26(F, ...) \
+	Z_UTIL_LISTIFY_25(F, __VA_ARGS__) \
+	F(25, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_27(F, ...) \
+	Z_UTIL_LISTIFY_26(F, __VA_ARGS__) \
+	F(26, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_28(F, ...) \
+	Z_UTIL_LISTIFY_27(F, __VA_ARGS__) \
+	F(27, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_29(F, ...) \
+	Z_UTIL_LISTIFY_28(F, __VA_ARGS__) \
+	F(28, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_30(F, ...) \
+	Z_UTIL_LISTIFY_29(F, __VA_ARGS__) \
+	F(29, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_31(F, ...) \
+	Z_UTIL_LISTIFY_30(F, __VA_ARGS__) \
+	F(30, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_32(F, ...) \
+	Z_UTIL_LISTIFY_31(F, __VA_ARGS__) \
+	F(31, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_33(F, ...) \
+	Z_UTIL_LISTIFY_32(F, __VA_ARGS__) \
+	F(32, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_34(F, ...) \
+	Z_UTIL_LISTIFY_33(F, __VA_ARGS__) \
+	F(33, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_35(F, ...) \
+	Z_UTIL_LISTIFY_34(F, __VA_ARGS__) \
+	F(34, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_36(F, ...) \
+	Z_UTIL_LISTIFY_35(F, __VA_ARGS__) \
+	F(35, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_37(F, ...) \
+	Z_UTIL_LISTIFY_36(F, __VA_ARGS__) \
+	F(36, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_38(F, ...) \
+	Z_UTIL_LISTIFY_37(F, __VA_ARGS__) \
+	F(37, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_39(F, ...) \
+	Z_UTIL_LISTIFY_38(F, __VA_ARGS__) \
+	F(38, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_40(F, ...) \
+	Z_UTIL_LISTIFY_39(F, __VA_ARGS__) \
+	F(39, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_41(F, ...) \
+	Z_UTIL_LISTIFY_40(F, __VA_ARGS__) \
+	F(40, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_42(F, ...) \
+	Z_UTIL_LISTIFY_41(F, __VA_ARGS__) \
+	F(41, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_43(F, ...) \
+	Z_UTIL_LISTIFY_42(F, __VA_ARGS__) \
+	F(42, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_44(F, ...) \
+	Z_UTIL_LISTIFY_43(F, __VA_ARGS__) \
+	F(43, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_45(F, ...) \
+	Z_UTIL_LISTIFY_44(F, __VA_ARGS__) \
+	F(44, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_46(F, ...) \
+	Z_UTIL_LISTIFY_45(F, __VA_ARGS__) \
+	F(45, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_47(F, ...) \
+	Z_UTIL_LISTIFY_46(F, __VA_ARGS__) \
+	F(46, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_48(F, ...) \
+	Z_UTIL_LISTIFY_47(F, __VA_ARGS__) \
+	F(47, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_49(F, ...) \
+	Z_UTIL_LISTIFY_48(F, __VA_ARGS__) \
+	F(48, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_50(F, ...) \
+	Z_UTIL_LISTIFY_49(F, __VA_ARGS__) \
+	F(49, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_51(F, ...) \
+	Z_UTIL_LISTIFY_50(F, __VA_ARGS__) \
+	F(50, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_52(F, ...) \
+	Z_UTIL_LISTIFY_51(F, __VA_ARGS__) \
+	F(51, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_53(F, ...) \
+	Z_UTIL_LISTIFY_52(F, __VA_ARGS__) \
+	F(52, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_54(F, ...) \
+	Z_UTIL_LISTIFY_53(F, __VA_ARGS__) \
+	F(53, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_55(F, ...) \
+	Z_UTIL_LISTIFY_54(F, __VA_ARGS__) \
+	F(54, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_56(F, ...) \
+	Z_UTIL_LISTIFY_55(F, __VA_ARGS__) \
+	F(55, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_57(F, ...) \
+	Z_UTIL_LISTIFY_56(F, __VA_ARGS__) \
+	F(56, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_58(F, ...) \
+	Z_UTIL_LISTIFY_57(F, __VA_ARGS__) \
+	F(57, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_59(F, ...) \
+	Z_UTIL_LISTIFY_58(F, __VA_ARGS__) \
+	F(58, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_60(F, ...) \
+	Z_UTIL_LISTIFY_59(F, __VA_ARGS__) \
+	F(59, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_61(F, ...) \
+	Z_UTIL_LISTIFY_60(F, __VA_ARGS__) \
+	F(60, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_62(F, ...) \
+	Z_UTIL_LISTIFY_61(F, __VA_ARGS__) \
+	F(61, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_63(F, ...) \
+	Z_UTIL_LISTIFY_62(F, __VA_ARGS__) \
+	F(62, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_64(F, ...) \
+	Z_UTIL_LISTIFY_63(F, __VA_ARGS__) \
+	F(63, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_65(F, ...) \
+	Z_UTIL_LISTIFY_64(F, __VA_ARGS__) \
+	F(64, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_66(F, ...) \
+	Z_UTIL_LISTIFY_65(F, __VA_ARGS__) \
+	F(65, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_67(F, ...) \
+	Z_UTIL_LISTIFY_66(F, __VA_ARGS__) \
+	F(66, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_68(F, ...) \
+	Z_UTIL_LISTIFY_67(F, __VA_ARGS__) \
+	F(67, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_69(F, ...) \
+	Z_UTIL_LISTIFY_68(F, __VA_ARGS__) \
+	F(68, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_70(F, ...) \
+	Z_UTIL_LISTIFY_69(F, __VA_ARGS__) \
+	F(69, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_71(F, ...) \
+	Z_UTIL_LISTIFY_70(F, __VA_ARGS__) \
+	F(70, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_72(F, ...) \
+	Z_UTIL_LISTIFY_71(F, __VA_ARGS__) \
+	F(71, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_73(F, ...) \
+	Z_UTIL_LISTIFY_72(F, __VA_ARGS__) \
+	F(72, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_74(F, ...) \
+	Z_UTIL_LISTIFY_73(F, __VA_ARGS__) \
+	F(73, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_75(F, ...) \
+	Z_UTIL_LISTIFY_74(F, __VA_ARGS__) \
+	F(74, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_76(F, ...) \
+	Z_UTIL_LISTIFY_75(F, __VA_ARGS__) \
+	F(75, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_77(F, ...) \
+	Z_UTIL_LISTIFY_76(F, __VA_ARGS__) \
+	F(76, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_78(F, ...) \
+	Z_UTIL_LISTIFY_77(F, __VA_ARGS__) \
+	F(77, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_79(F, ...) \
+	Z_UTIL_LISTIFY_78(F, __VA_ARGS__) \
+	F(78, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_80(F, ...) \
+	Z_UTIL_LISTIFY_79(F, __VA_ARGS__) \
+	F(79, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_81(F, ...) \
+	Z_UTIL_LISTIFY_80(F, __VA_ARGS__) \
+	F(80, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_82(F, ...) \
+	Z_UTIL_LISTIFY_81(F, __VA_ARGS__) \
+	F(81, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_83(F, ...) \
+	Z_UTIL_LISTIFY_82(F, __VA_ARGS__) \
+	F(82, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_84(F, ...) \
+	Z_UTIL_LISTIFY_83(F, __VA_ARGS__) \
+	F(83, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_85(F, ...) \
+	Z_UTIL_LISTIFY_84(F, __VA_ARGS__) \
+	F(84, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_86(F, ...) \
+	Z_UTIL_LISTIFY_85(F, __VA_ARGS__) \
+	F(85, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_87(F, ...) \
+	Z_UTIL_LISTIFY_86(F, __VA_ARGS__) \
+	F(86, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_88(F, ...) \
+	Z_UTIL_LISTIFY_87(F, __VA_ARGS__) \
+	F(87, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_89(F, ...) \
+	Z_UTIL_LISTIFY_88(F, __VA_ARGS__) \
+	F(88, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_90(F, ...) \
+	Z_UTIL_LISTIFY_89(F, __VA_ARGS__) \
+	F(89, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_91(F, ...) \
+	Z_UTIL_LISTIFY_90(F, __VA_ARGS__) \
+	F(90, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_92(F, ...) \
+	Z_UTIL_LISTIFY_91(F, __VA_ARGS__) \
+	F(91, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_93(F, ...) \
+	Z_UTIL_LISTIFY_92(F, __VA_ARGS__) \
+	F(92, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_94(F, ...) \
+	Z_UTIL_LISTIFY_93(F, __VA_ARGS__) \
+	F(93, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_95(F, ...) \
+	Z_UTIL_LISTIFY_94(F, __VA_ARGS__) \
+	F(94, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_96(F, ...) \
+	Z_UTIL_LISTIFY_95(F, __VA_ARGS__) \
+	F(95, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_97(F, ...) \
+	Z_UTIL_LISTIFY_96(F, __VA_ARGS__) \
+	F(96, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_98(F, ...) \
+	Z_UTIL_LISTIFY_97(F, __VA_ARGS__) \
+	F(97, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_99(F, ...) \
+	Z_UTIL_LISTIFY_98(F, __VA_ARGS__) \
+	F(98, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_100(F, ...) \
+	Z_UTIL_LISTIFY_99(F, __VA_ARGS__) \
+	F(99, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_101(F, ...) \
+	Z_UTIL_LISTIFY_100(F, __VA_ARGS__) \
+	F(100, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_102(F, ...) \
+	Z_UTIL_LISTIFY_101(F, __VA_ARGS__) \
+	F(101, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_103(F, ...) \
+	Z_UTIL_LISTIFY_102(F, __VA_ARGS__) \
+	F(102, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_104(F, ...) \
+	Z_UTIL_LISTIFY_103(F, __VA_ARGS__) \
+	F(103, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_105(F, ...) \
+	Z_UTIL_LISTIFY_104(F, __VA_ARGS__) \
+	F(104, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_106(F, ...) \
+	Z_UTIL_LISTIFY_105(F, __VA_ARGS__) \
+	F(105, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_107(F, ...) \
+	Z_UTIL_LISTIFY_106(F, __VA_ARGS__) \
+	F(106, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_108(F, ...) \
+	Z_UTIL_LISTIFY_107(F, __VA_ARGS__) \
+	F(107, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_109(F, ...) \
+	Z_UTIL_LISTIFY_108(F, __VA_ARGS__) \
+	F(108, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_110(F, ...) \
+	Z_UTIL_LISTIFY_109(F, __VA_ARGS__) \
+	F(109, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_111(F, ...) \
+	Z_UTIL_LISTIFY_110(F, __VA_ARGS__) \
+	F(110, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_112(F, ...) \
+	Z_UTIL_LISTIFY_111(F, __VA_ARGS__) \
+	F(111, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_113(F, ...) \
+	Z_UTIL_LISTIFY_112(F, __VA_ARGS__) \
+	F(112, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_114(F, ...) \
+	Z_UTIL_LISTIFY_113(F, __VA_ARGS__) \
+	F(113, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_115(F, ...) \
+	Z_UTIL_LISTIFY_114(F, __VA_ARGS__) \
+	F(114, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_116(F, ...) \
+	Z_UTIL_LISTIFY_115(F, __VA_ARGS__) \
+	F(115, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_117(F, ...) \
+	Z_UTIL_LISTIFY_116(F, __VA_ARGS__) \
+	F(116, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_118(F, ...) \
+	Z_UTIL_LISTIFY_117(F, __VA_ARGS__) \
+	F(117, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_119(F, ...) \
+	Z_UTIL_LISTIFY_118(F, __VA_ARGS__) \
+	F(118, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_120(F, ...) \
+	Z_UTIL_LISTIFY_119(F, __VA_ARGS__) \
+	F(119, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_121(F, ...) \
+	Z_UTIL_LISTIFY_120(F, __VA_ARGS__) \
+	F(120, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_122(F, ...) \
+	Z_UTIL_LISTIFY_121(F, __VA_ARGS__) \
+	F(121, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_123(F, ...) \
+	Z_UTIL_LISTIFY_122(F, __VA_ARGS__) \
+	F(122, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_124(F, ...) \
+	Z_UTIL_LISTIFY_123(F, __VA_ARGS__) \
+	F(123, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_125(F, ...) \
+	Z_UTIL_LISTIFY_124(F, __VA_ARGS__) \
+	F(124, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_126(F, ...) \
+	Z_UTIL_LISTIFY_125(F, __VA_ARGS__) \
+	F(125, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_127(F, ...) \
+	Z_UTIL_LISTIFY_126(F, __VA_ARGS__) \
+	F(126, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_128(F, ...) \
+	Z_UTIL_LISTIFY_127(F, __VA_ARGS__) \
+	F(127, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_129(F, ...) \
+	Z_UTIL_LISTIFY_128(F, __VA_ARGS__) \
+	F(128, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_130(F, ...) \
+	Z_UTIL_LISTIFY_129(F, __VA_ARGS__) \
+	F(129, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_131(F, ...) \
+	Z_UTIL_LISTIFY_130(F, __VA_ARGS__) \
+	F(130, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_132(F, ...) \
+	Z_UTIL_LISTIFY_131(F, __VA_ARGS__) \
+	F(131, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_133(F, ...) \
+	Z_UTIL_LISTIFY_132(F, __VA_ARGS__) \
+	F(132, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_134(F, ...) \
+	Z_UTIL_LISTIFY_133(F, __VA_ARGS__) \
+	F(133, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_135(F, ...) \
+	Z_UTIL_LISTIFY_134(F, __VA_ARGS__) \
+	F(134, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_136(F, ...) \
+	Z_UTIL_LISTIFY_135(F, __VA_ARGS__) \
+	F(135, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_137(F, ...) \
+	Z_UTIL_LISTIFY_136(F, __VA_ARGS__) \
+	F(136, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_138(F, ...) \
+	Z_UTIL_LISTIFY_137(F, __VA_ARGS__) \
+	F(137, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_139(F, ...) \
+	Z_UTIL_LISTIFY_138(F, __VA_ARGS__) \
+	F(138, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_140(F, ...) \
+	Z_UTIL_LISTIFY_139(F, __VA_ARGS__) \
+	F(139, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_141(F, ...) \
+	Z_UTIL_LISTIFY_140(F, __VA_ARGS__) \
+	F(140, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_142(F, ...) \
+	Z_UTIL_LISTIFY_141(F, __VA_ARGS__) \
+	F(141, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_143(F, ...) \
+	Z_UTIL_LISTIFY_142(F, __VA_ARGS__) \
+	F(142, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_144(F, ...) \
+	Z_UTIL_LISTIFY_143(F, __VA_ARGS__) \
+	F(143, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_145(F, ...) \
+	Z_UTIL_LISTIFY_144(F, __VA_ARGS__) \
+	F(144, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_146(F, ...) \
+	Z_UTIL_LISTIFY_145(F, __VA_ARGS__) \
+	F(145, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_147(F, ...) \
+	Z_UTIL_LISTIFY_146(F, __VA_ARGS__) \
+	F(146, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_148(F, ...) \
+	Z_UTIL_LISTIFY_147(F, __VA_ARGS__) \
+	F(147, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_149(F, ...) \
+	Z_UTIL_LISTIFY_148(F, __VA_ARGS__) \
+	F(148, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_150(F, ...) \
+	Z_UTIL_LISTIFY_149(F, __VA_ARGS__) \
+	F(149, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_151(F, ...) \
+	Z_UTIL_LISTIFY_150(F, __VA_ARGS__) \
+	F(150, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_152(F, ...) \
+	Z_UTIL_LISTIFY_151(F, __VA_ARGS__) \
+	F(151, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_153(F, ...) \
+	Z_UTIL_LISTIFY_152(F, __VA_ARGS__) \
+	F(152, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_154(F, ...) \
+	Z_UTIL_LISTIFY_153(F, __VA_ARGS__) \
+	F(153, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_155(F, ...) \
+	Z_UTIL_LISTIFY_154(F, __VA_ARGS__) \
+	F(154, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_156(F, ...) \
+	Z_UTIL_LISTIFY_155(F, __VA_ARGS__) \
+	F(155, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_157(F, ...) \
+	Z_UTIL_LISTIFY_156(F, __VA_ARGS__) \
+	F(156, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_158(F, ...) \
+	Z_UTIL_LISTIFY_157(F, __VA_ARGS__) \
+	F(157, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_159(F, ...) \
+	Z_UTIL_LISTIFY_158(F, __VA_ARGS__) \
+	F(158, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_160(F, ...) \
+	Z_UTIL_LISTIFY_159(F, __VA_ARGS__) \
+	F(159, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_161(F, ...) \
+	Z_UTIL_LISTIFY_160(F, __VA_ARGS__) \
+	F(160, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_162(F, ...) \
+	Z_UTIL_LISTIFY_161(F, __VA_ARGS__) \
+	F(161, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_163(F, ...) \
+	Z_UTIL_LISTIFY_162(F, __VA_ARGS__) \
+	F(162, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_164(F, ...) \
+	Z_UTIL_LISTIFY_163(F, __VA_ARGS__) \
+	F(163, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_165(F, ...) \
+	Z_UTIL_LISTIFY_164(F, __VA_ARGS__) \
+	F(164, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_166(F, ...) \
+	Z_UTIL_LISTIFY_165(F, __VA_ARGS__) \
+	F(165, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_167(F, ...) \
+	Z_UTIL_LISTIFY_166(F, __VA_ARGS__) \
+	F(166, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_168(F, ...) \
+	Z_UTIL_LISTIFY_167(F, __VA_ARGS__) \
+	F(167, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_169(F, ...) \
+	Z_UTIL_LISTIFY_168(F, __VA_ARGS__) \
+	F(168, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_170(F, ...) \
+	Z_UTIL_LISTIFY_169(F, __VA_ARGS__) \
+	F(169, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_171(F, ...) \
+	Z_UTIL_LISTIFY_170(F, __VA_ARGS__) \
+	F(170, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_172(F, ...) \
+	Z_UTIL_LISTIFY_171(F, __VA_ARGS__) \
+	F(171, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_173(F, ...) \
+	Z_UTIL_LISTIFY_172(F, __VA_ARGS__) \
+	F(172, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_174(F, ...) \
+	Z_UTIL_LISTIFY_173(F, __VA_ARGS__) \
+	F(173, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_175(F, ...) \
+	Z_UTIL_LISTIFY_174(F, __VA_ARGS__) \
+	F(174, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_176(F, ...) \
+	Z_UTIL_LISTIFY_175(F, __VA_ARGS__) \
+	F(175, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_177(F, ...) \
+	Z_UTIL_LISTIFY_176(F, __VA_ARGS__) \
+	F(176, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_178(F, ...) \
+	Z_UTIL_LISTIFY_177(F, __VA_ARGS__) \
+	F(177, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_179(F, ...) \
+	Z_UTIL_LISTIFY_178(F, __VA_ARGS__) \
+	F(178, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_180(F, ...) \
+	Z_UTIL_LISTIFY_179(F, __VA_ARGS__) \
+	F(179, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_181(F, ...) \
+	Z_UTIL_LISTIFY_180(F, __VA_ARGS__) \
+	F(180, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_182(F, ...) \
+	Z_UTIL_LISTIFY_181(F, __VA_ARGS__) \
+	F(181, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_183(F, ...) \
+	Z_UTIL_LISTIFY_182(F, __VA_ARGS__) \
+	F(182, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_184(F, ...) \
+	Z_UTIL_LISTIFY_183(F, __VA_ARGS__) \
+	F(183, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_185(F, ...) \
+	Z_UTIL_LISTIFY_184(F, __VA_ARGS__) \
+	F(184, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_186(F, ...) \
+	Z_UTIL_LISTIFY_185(F, __VA_ARGS__) \
+	F(185, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_187(F, ...) \
+	Z_UTIL_LISTIFY_186(F, __VA_ARGS__) \
+	F(186, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_188(F, ...) \
+	Z_UTIL_LISTIFY_187(F, __VA_ARGS__) \
+	F(187, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_189(F, ...) \
+	Z_UTIL_LISTIFY_188(F, __VA_ARGS__) \
+	F(188, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_190(F, ...) \
+	Z_UTIL_LISTIFY_189(F, __VA_ARGS__) \
+	F(189, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_191(F, ...) \
+	Z_UTIL_LISTIFY_190(F, __VA_ARGS__) \
+	F(190, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_192(F, ...) \
+	Z_UTIL_LISTIFY_191(F, __VA_ARGS__) \
+	F(191, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_193(F, ...) \
+	Z_UTIL_LISTIFY_192(F, __VA_ARGS__) \
+	F(192, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_194(F, ...) \
+	Z_UTIL_LISTIFY_193(F, __VA_ARGS__) \
+	F(193, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_195(F, ...) \
+	Z_UTIL_LISTIFY_194(F, __VA_ARGS__) \
+	F(194, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_196(F, ...) \
+	Z_UTIL_LISTIFY_195(F, __VA_ARGS__) \
+	F(195, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_197(F, ...) \
+	Z_UTIL_LISTIFY_196(F, __VA_ARGS__) \
+	F(196, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_198(F, ...) \
+	Z_UTIL_LISTIFY_197(F, __VA_ARGS__) \
+	F(197, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_199(F, ...) \
+	Z_UTIL_LISTIFY_198(F, __VA_ARGS__) \
+	F(198, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_200(F, ...) \
+	Z_UTIL_LISTIFY_199(F, __VA_ARGS__) \
+	F(199, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_201(F, ...) \
+	Z_UTIL_LISTIFY_200(F, __VA_ARGS__) \
+	F(200, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_202(F, ...) \
+	Z_UTIL_LISTIFY_201(F, __VA_ARGS__) \
+	F(201, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_203(F, ...) \
+	Z_UTIL_LISTIFY_202(F, __VA_ARGS__) \
+	F(202, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_204(F, ...) \
+	Z_UTIL_LISTIFY_203(F, __VA_ARGS__) \
+	F(203, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_205(F, ...) \
+	Z_UTIL_LISTIFY_204(F, __VA_ARGS__) \
+	F(204, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_206(F, ...) \
+	Z_UTIL_LISTIFY_205(F, __VA_ARGS__) \
+	F(205, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_207(F, ...) \
+	Z_UTIL_LISTIFY_206(F, __VA_ARGS__) \
+	F(206, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_208(F, ...) \
+	Z_UTIL_LISTIFY_207(F, __VA_ARGS__) \
+	F(207, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_209(F, ...) \
+	Z_UTIL_LISTIFY_208(F, __VA_ARGS__) \
+	F(208, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_210(F, ...) \
+	Z_UTIL_LISTIFY_209(F, __VA_ARGS__) \
+	F(209, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_211(F, ...) \
+	Z_UTIL_LISTIFY_210(F, __VA_ARGS__) \
+	F(210, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_212(F, ...) \
+	Z_UTIL_LISTIFY_211(F, __VA_ARGS__) \
+	F(211, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_213(F, ...) \
+	Z_UTIL_LISTIFY_212(F, __VA_ARGS__) \
+	F(212, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_214(F, ...) \
+	Z_UTIL_LISTIFY_213(F, __VA_ARGS__) \
+	F(213, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_215(F, ...) \
+	Z_UTIL_LISTIFY_214(F, __VA_ARGS__) \
+	F(214, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_216(F, ...) \
+	Z_UTIL_LISTIFY_215(F, __VA_ARGS__) \
+	F(215, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_217(F, ...) \
+	Z_UTIL_LISTIFY_216(F, __VA_ARGS__) \
+	F(216, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_218(F, ...) \
+	Z_UTIL_LISTIFY_217(F, __VA_ARGS__) \
+	F(217, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_219(F, ...) \
+	Z_UTIL_LISTIFY_218(F, __VA_ARGS__) \
+	F(218, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_220(F, ...) \
+	Z_UTIL_LISTIFY_219(F, __VA_ARGS__) \
+	F(219, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_221(F, ...) \
+	Z_UTIL_LISTIFY_220(F, __VA_ARGS__) \
+	F(220, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_222(F, ...) \
+	Z_UTIL_LISTIFY_221(F, __VA_ARGS__) \
+	F(221, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_223(F, ...) \
+	Z_UTIL_LISTIFY_222(F, __VA_ARGS__) \
+	F(222, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_224(F, ...) \
+	Z_UTIL_LISTIFY_223(F, __VA_ARGS__) \
+	F(223, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_225(F, ...) \
+	Z_UTIL_LISTIFY_224(F, __VA_ARGS__) \
+	F(224, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_226(F, ...) \
+	Z_UTIL_LISTIFY_225(F, __VA_ARGS__) \
+	F(225, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_227(F, ...) \
+	Z_UTIL_LISTIFY_226(F, __VA_ARGS__) \
+	F(226, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_228(F, ...) \
+	Z_UTIL_LISTIFY_227(F, __VA_ARGS__) \
+	F(227, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_229(F, ...) \
+	Z_UTIL_LISTIFY_228(F, __VA_ARGS__) \
+	F(228, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_230(F, ...) \
+	Z_UTIL_LISTIFY_229(F, __VA_ARGS__) \
+	F(229, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_231(F, ...) \
+	Z_UTIL_LISTIFY_230(F, __VA_ARGS__) \
+	F(230, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_232(F, ...) \
+	Z_UTIL_LISTIFY_231(F, __VA_ARGS__) \
+	F(231, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_233(F, ...) \
+	Z_UTIL_LISTIFY_232(F, __VA_ARGS__) \
+	F(232, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_234(F, ...) \
+	Z_UTIL_LISTIFY_233(F, __VA_ARGS__) \
+	F(233, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_235(F, ...) \
+	Z_UTIL_LISTIFY_234(F, __VA_ARGS__) \
+	F(234, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_236(F, ...) \
+	Z_UTIL_LISTIFY_235(F, __VA_ARGS__) \
+	F(235, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_237(F, ...) \
+	Z_UTIL_LISTIFY_236(F, __VA_ARGS__) \
+	F(236, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_238(F, ...) \
+	Z_UTIL_LISTIFY_237(F, __VA_ARGS__) \
+	F(237, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_239(F, ...) \
+	Z_UTIL_LISTIFY_238(F, __VA_ARGS__) \
+	F(238, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_240(F, ...) \
+	Z_UTIL_LISTIFY_239(F, __VA_ARGS__) \
+	F(239, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_241(F, ...) \
+	Z_UTIL_LISTIFY_240(F, __VA_ARGS__) \
+	F(240, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_242(F, ...) \
+	Z_UTIL_LISTIFY_241(F, __VA_ARGS__) \
+	F(241, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_243(F, ...) \
+	Z_UTIL_LISTIFY_242(F, __VA_ARGS__) \
+	F(242, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_244(F, ...) \
+	Z_UTIL_LISTIFY_243(F, __VA_ARGS__) \
+	F(243, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_245(F, ...) \
+	Z_UTIL_LISTIFY_244(F, __VA_ARGS__) \
+	F(244, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_246(F, ...) \
+	Z_UTIL_LISTIFY_245(F, __VA_ARGS__) \
+	F(245, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_247(F, ...) \
+	Z_UTIL_LISTIFY_246(F, __VA_ARGS__) \
+	F(246, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_248(F, ...) \
+	Z_UTIL_LISTIFY_247(F, __VA_ARGS__) \
+	F(247, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_249(F, ...) \
+	Z_UTIL_LISTIFY_248(F, __VA_ARGS__) \
+	F(248, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_250(F, ...) \
+	Z_UTIL_LISTIFY_249(F, __VA_ARGS__) \
+	F(249, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_251(F, ...) \
+	Z_UTIL_LISTIFY_250(F, __VA_ARGS__) \
+	F(250, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_252(F, ...) \
+	Z_UTIL_LISTIFY_251(F, __VA_ARGS__) \
+	F(251, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_253(F, ...) \
+	Z_UTIL_LISTIFY_252(F, __VA_ARGS__) \
+	F(252, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_254(F, ...) \
+	Z_UTIL_LISTIFY_253(F, __VA_ARGS__) \
+	F(253, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_255(F, ...) \
+	Z_UTIL_LISTIFY_254(F, __VA_ARGS__) \
+	F(254, __VA_ARGS__)
+
+#define Z_UTIL_LISTIFY_256(F, ...) \
+	Z_UTIL_LISTIFY_255(F, __VA_ARGS__) \
+	F(255, __VA_ARGS__)
+
+#endif /* ZEPHYR_INCLUDE_SYS_UTIL_LOOPS_H_ */
diff --git a/framework/include/dt_sys/util_macro.h b/framework/include/dt_sys/util_macro.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f81be0b894794ab018126ba19461bad9a69f018
--- /dev/null
+++ b/framework/include/dt_sys/util_macro.h
@@ -0,0 +1,610 @@
+/*
+ * Copyright (c) 2011-2014, Wind River Systems, Inc.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @file
+ * @brief Macro utilities
+ *
+ * Macro utilities are the public interface for C/C++ code and device tree
+ * related implementation.  In general, C/C++ will include <sys/util.h>
+ * instead this file directly.  For device tree implementation, this file
+ * should be include instead <sys/util_internal.h>
+ */
+
+#ifndef ZEPHYR_INCLUDE_SYS_UTIL_MACROS_H_
+#define ZEPHYR_INCLUDE_SYS_UTIL_MACROS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @addtogroup sys-util
+ * @{
+ */
+
+/*
+ * Most of the eldritch implementation details for all the macrobatics
+ * below (APIs like IS_ENABLED(), COND_CODE_1(), etc.) are hidden away
+ * in this file.
+ */
+#include <dt_sys/util_internal.h>
+
+#ifndef BIT
+#if defined(_ASMLANGUAGE)
+#define BIT(n)  (1 << (n))
+#else
+/**
+ * @brief Unsigned integer with bit position @p n set (signed in
+ * assembly language).
+ */
+#define BIT(n)  (1UL << (n))
+#endif
+#endif
+
+/** @brief 64-bit unsigned integer with bit position @p _n set. */
+#define BIT64(_n) (1ULL << (_n))
+
+/**
+ * @brief Set or clear a bit depending on a boolean value
+ *
+ * The argument @p var is a variable whose value is written to as a
+ * side effect.
+ *
+ * @param var Variable to be altered
+ * @param bit Bit number
+ * @param set if 0, clears @p bit in @p var; any other value sets @p bit
+ */
+#define WRITE_BIT(var, bit, set) \
+	((var) = (set) ? ((var) | BIT(bit)) : ((var) & ~BIT(bit)))
+
+/**
+ * @brief Bit mask with bits 0 through <tt>n-1</tt> (inclusive) set,
+ * or 0 if @p n is 0.
+ */
+#define BIT_MASK(n) (BIT(n) - 1UL)
+
+/**
+ * @brief 64-bit bit mask with bits 0 through <tt>n-1</tt> (inclusive) set,
+ * or 0 if @p n is 0.
+ */
+#define BIT64_MASK(n) (BIT64(n) - 1ULL)
+
+/**
+ * @brief Check for macro definition in compiler-visible expressions
+ *
+ * This trick was pioneered in Linux as the config_enabled() macro. It
+ * has the effect of taking a macro value that may be defined to "1"
+ * or may not be defined at all and turning it into a literal
+ * expression that can be handled by the C compiler instead of just
+ * the preprocessor. It is often used with a @p CONFIG_FOO macro which
+ * may be defined to 1 via Kconfig, or left undefined.
+ *
+ * That is, it works similarly to <tt>\#if defined(CONFIG_FOO)</tt>
+ * except that its expansion is a C expression. Thus, much <tt>\#ifdef</tt>
+ * usage can be replaced with equivalents like:
+ *
+ *     if (IS_ENABLED(CONFIG_FOO)) {
+ *             do_something_with_foo
+ *     }
+ *
+ * This is cleaner since the compiler can generate errors and warnings
+ * for @p do_something_with_foo even when @p CONFIG_FOO is undefined.
+ *
+ * @param config_macro Macro to check
+ * @return 1 if @p config_macro is defined to 1, 0 otherwise (including
+ *         if @p config_macro is not defined)
+ */
+#define IS_ENABLED(config_macro) Z_IS_ENABLED1(config_macro)
+/* INTERNAL: the first pass above is just to expand any existing
+ * macros, we need the macro value to be e.g. a literal "1" at
+ * expansion time in the next macro, not "(1)", etc... Standard
+ * recursive expansion does not work.
+ */
+
+/**
+ * @brief Insert code depending on whether @p _flag expands to 1 or not.
+ *
+ * This relies on similar tricks as IS_ENABLED(), but as the result of
+ * @p _flag expansion, results in either @p _if_1_code or @p
+ * _else_code is expanded.
+ *
+ * To prevent the preprocessor from treating commas as argument
+ * separators, the @p _if_1_code and @p _else_code expressions must be
+ * inside brackets/parentheses: <tt>()</tt>. These are stripped away
+ * during macro expansion.
+ *
+ * Example:
+ *
+ *     COND_CODE_1(CONFIG_FLAG, (uint32_t x;), (there_is_no_flag();))
+ *
+ * If @p CONFIG_FLAG is defined to 1, this expands to:
+ *
+ *     uint32_t x;
+ *
+ * It expands to <tt>there_is_no_flag();</tt> otherwise.
+ *
+ * This could be used as an alternative to:
+ *
+ *     #if defined(CONFIG_FLAG) && (CONFIG_FLAG == 1)
+ *     #define MAYBE_DECLARE(x) uint32_t x
+ *     #else
+ *     #define MAYBE_DECLARE(x) there_is_no_flag()
+ *     #endif
+ *
+ *     MAYBE_DECLARE(x);
+ *
+ * However, the advantage of COND_CODE_1() is that code is resolved in
+ * place where it is used, while the @p \#if method defines @p
+ * MAYBE_DECLARE on two lines and requires it to be invoked again on a
+ * separate line. This makes COND_CODE_1() more concise and also
+ * sometimes more useful when used within another macro's expansion.
+ *
+ * @note @p _flag can be the result of preprocessor expansion, e.g.
+ *	 an expression involving <tt>NUM_VA_ARGS_LESS_1(...)</tt>.
+ *	 However, @p _if_1_code is only expanded if @p _flag expands
+ *	 to the integer literal 1. Integer expressions that evaluate
+ *	 to 1, e.g. after doing some arithmetic, will not work.
+ *
+ * @param _flag evaluated flag
+ * @param _if_1_code result if @p _flag expands to 1; must be in parentheses
+ * @param _else_code result otherwise; must be in parentheses
+ */
+#define COND_CODE_1(_flag, _if_1_code, _else_code) \
+	Z_COND_CODE_1(_flag, _if_1_code, _else_code)
+
+/**
+ * @brief Like COND_CODE_1() except tests if @p _flag is 0.
+ *
+ * This is like COND_CODE_1(), except that it tests whether @p _flag
+ * expands to the integer literal 0. It expands to @p _if_0_code if
+ * so, and @p _else_code otherwise; both of these must be enclosed in
+ * parentheses.
+ *
+ * @param _flag evaluated flag
+ * @param _if_0_code result if @p _flag expands to 0; must be in parentheses
+ * @param _else_code result otherwise; must be in parentheses
+ * @see COND_CODE_1()
+ */
+#define COND_CODE_0(_flag, _if_0_code, _else_code) \
+	Z_COND_CODE_0(_flag, _if_0_code, _else_code)
+
+/**
+ * @brief Insert code if @p _flag is defined and equals 1.
+ *
+ * Like COND_CODE_1(), this expands to @p _code if @p _flag is defined to 1;
+ * it expands to nothing otherwise.
+ *
+ * Example:
+ *
+ *     IF_ENABLED(CONFIG_FLAG, (uint32_t foo;))
+ *
+ * If @p CONFIG_FLAG is defined to 1, this expands to:
+ *
+ *     uint32_t foo;
+ *
+ * and to nothing otherwise.
+ *
+ * It can be considered as a more compact alternative to:
+ *
+ *     #if defined(CONFIG_FLAG) && (CONFIG_FLAG == 1)
+ *     uint32_t foo;
+ *     #endif
+ *
+ * @param _flag evaluated flag
+ * @param _code result if @p _flag expands to 1; must be in parentheses
+ */
+#define IF_ENABLED(_flag, _code) \
+	COND_CODE_1(_flag, _code, ())
+
+/**
+ * @brief Check if a macro has a replacement expression
+ *
+ * If @p a is a macro defined to a nonempty value, this will return
+ * true, otherwise it will return false. It only works with defined
+ * macros, so an additional @p \#ifdef test may be needed in some cases.
+ *
+ * This macro may be used with COND_CODE_1() and COND_CODE_0() while
+ * processing <tt>__VA_ARGS__</tt> to avoid processing empty arguments.
+ *
+ * Note that this macro is intended to check macro names that evaluate
+ * to replacement lists being empty or containing numbers or macro name
+ * like tokens.
+ *
+ * @note Not all arguments are accepted by this macro and compilation will fail
+ *	 if argument cannot be concatenated with literal constant. That will
+ *	 happen if argument does not start with letter or number. Example
+ *	 arguments that will fail during compilation: .arg, (arg), "arg", {arg}.
+ *
+ * Example:
+ *
+ *	#define EMPTY
+ *	#define NON_EMPTY	1
+ *	#undef  UNDEFINED
+ *	IS_EMPTY(EMPTY)
+ *	IS_EMPTY(NON_EMPTY)
+ *	IS_EMPTY(UNDEFINED)
+ *	#if defined(EMPTY) && IS_EMPTY(EMPTY) == true
+ *	some_conditional_code
+ *	#endif
+ *
+ * In above examples, the invocations of IS_EMPTY(...) return @p true,
+ * @p false, and @p true; @p some_conditional_code is included.
+ *
+ * @param a macro to check for emptiness
+ */
+#define IS_EMPTY(a) Z_IS_EMPTY_(a, 1, 0,)
+
+/**
+ * @brief Remove empty arguments from list.
+ *
+ * During macro expansion, <tt>__VA_ARGS__</tt> and other preprocessor
+ * generated lists may contain empty elements, e.g.:
+ *
+ *	#define LIST ,a,b,,d,
+ *
+ * Using EMPTY to show each empty element, LIST contains:
+ *
+ *      EMPTY, a, b, EMPTY, d
+ *
+ * When processing such lists, e.g. using FOR_EACH(), all empty elements
+ * will be processed, and may require filtering out.
+ * To make that process easier, it is enough to invoke LIST_DROP_EMPTY
+ * which will remove all empty elements.
+ *
+ * Example:
+ *
+ *	LIST_DROP_EMPTY(LIST)
+ *
+ * expands to:
+ *
+ *	a, b, d
+ *
+ * @param ... list to be processed
+ */
+#define LIST_DROP_EMPTY(...) \
+	Z_LIST_DROP_FIRST(FOR_EACH(Z_LIST_NO_EMPTIES, (), __VA_ARGS__))
+
+/**
+ * @brief Macro with an empty expansion
+ *
+ * This trivial definition is provided for readability when a macro
+ * should expand to an empty result, which e.g. is sometimes needed to
+ * silence checkpatch.
+ *
+ * Example:
+ *
+ *	#define LIST_ITEM(n) , item##n
+ *
+ * The above would cause checkpatch to complain, but:
+ *
+ *	#define LIST_ITEM(n) EMPTY, item##n
+ *
+ * would not.
+ */
+#define EMPTY
+
+/**
+ * @brief Macro that expands to its argument
+ *
+ * This is useful in macros like @c FOR_EACH() when there is no
+ * transformation required on the list elements.
+ *
+ * @param V any value
+ */
+#define IDENTITY(V) V
+
+/**
+ * @brief Get nth argument from argument list.
+ *
+ * @param N Argument index to fetch. Counter from 1.
+ * @param ... Variable list of argments from which one argument is returned.
+ *
+ * @return Nth argument.
+ */
+#define GET_ARG_N(N, ...) Z_GET_ARG_##N(__VA_ARGS__)
+
+/**
+ * @brief Strips n first arguments from the argument list.
+ *
+ * @param N Number of arguments to discard.
+ * @param ... Variable list of argments.
+ *
+ * @return argument list without N first arguments.
+ */
+#define GET_ARGS_LESS_N(N, ...) Z_GET_ARGS_LESS_##N(__VA_ARGS__)
+
+/**
+ * @brief Like <tt>a || b</tt>, but does evaluation and
+ * short-circuiting at C preprocessor time.
+ *
+ * This is not the same as the binary @p || operator; in particular,
+ * @p a should expand to an integer literal 0 or 1. However, @p b
+ * can be any value.
+ *
+ * This can be useful when @p b is an expression that would cause a
+ * build error when @p a is 1.
+ */
+#define UTIL_OR(a, b) COND_CODE_1(UTIL_BOOL(a), (a), (b))
+
+/**
+ * @brief Like <tt>a && b</tt>, but does evaluation and
+ * short-circuiting at C preprocessor time.
+ *
+ * This is not the same as the binary @p &&, however; in particular,
+ * @p a should expand to an integer literal 0 or 1. However, @p b
+ * can be any value.
+ *
+ * This can be useful when @p b is an expression that would cause a
+ * build error when @p a is 0.
+ */
+#define UTIL_AND(a, b) COND_CODE_1(UTIL_BOOL(a), (b), (0))
+
+/**
+ * @brief Generates a sequence of code.
+ *
+ * Example:
+ *
+ *     #define FOO(i, _) MY_PWM ## i ,
+ *     { UTIL_LISTIFY(PWM_COUNT, FOO) }
+ *
+ * The above two lines expand to:
+ *
+ *    { MY_PWM0 , MY_PWM1 , }
+ *
+ * @param LEN The length of the sequence. Must be an integer literal less
+ *            than 255.
+ * @param F A macro function that accepts at least two arguments:
+ *          <tt>F(i, ...)</tt>. @p F is called repeatedly in the expansion.
+ *          Its first argument @p i is the index in the sequence, and
+ *          the variable list of arguments passed to UTIL_LISTIFY are passed
+ *          through to @p F.
+ *
+ * @note Calling UTIL_LISTIFY with undefined arguments has undefined
+ * behavior.
+ */
+#define UTIL_LISTIFY(LEN, F, ...) UTIL_CAT(Z_UTIL_LISTIFY_, LEN)(F, __VA_ARGS__)
+
+/**
+ * @brief Call a macro @p F on each provided argument with a given
+ *        separator between each call.
+ *
+ * Example:
+ *
+ *     #define F(x) int a##x
+ *     FOR_EACH(F, (;), 4, 5, 6);
+ *
+ * This expands to:
+ *
+ *     int a4;
+ *     int a5;
+ *     int a6;
+ *
+ * @param F Macro to invoke
+ * @param sep Separator (e.g. comma or semicolon). Must be in parentheses;
+ *            this is required to enable providing a comma as separator.
+ * @param ... Variable argument list. The macro @p F is invoked as
+ *            <tt>F(element)</tt> for each element in the list.
+ */
+#define FOR_EACH(F, sep, ...) \
+	Z_FOR_EACH(F, sep, REVERSE_ARGS(__VA_ARGS__))
+
+/**
+ * @brief Like FOR_EACH(), but with a terminator instead of a separator,
+ *        and drops empty elements from the argument list
+ *
+ * The @p sep argument to <tt>FOR_EACH(F, (sep), a, b)</tt> is a
+ * separator which is placed between calls to @p F, like this:
+ *
+ *     FOR_EACH(F, (sep), a, b) // F(a) sep F(b)
+ *                              //               ^^^ no sep here!
+ *
+ * By contrast, the @p term argument to <tt>FOR_EACH_NONEMPTY_TERM(F, (term),
+ * a, b)</tt> is added after each time @p F appears in the expansion:
+ *
+ *     FOR_EACH_NONEMPTY_TERM(F, (term), a, b) // F(a) term F(b) term
+ *                                             //                ^^^^
+ *
+ * Further, any empty elements are dropped:
+ *
+ *     FOR_EACH_NONEMPTY_TERM(F, (term), a, EMPTY, b) // F(a) term F(b) term
+ *
+ * This is more convenient in some cases, because FOR_EACH_NONEMPTY_TERM()
+ * expands to nothing when given an empty argument list, and it's
+ * often cumbersome to write a macro @p F that does the right thing
+ * even when given an empty argument.
+ *
+ * One example is when <tt>__VA_ARGS__</tt> may or may not be empty,
+ * and the results are embedded in a larger initializer:
+ *
+ *     #define SQUARE(x) ((x)*(x))
+ *
+ *     int my_array[] = {
+ *             FOR_EACH_NONEMPTY_TERM(SQUARE, (,), FOO(...))
+ *             FOR_EACH_NONEMPTY_TERM(SQUARE, (,), BAR(...))
+ *             FOR_EACH_NONEMPTY_TERM(SQUARE, (,), BAZ(...))
+ *     };
+ *
+ * This is more convenient than:
+ *
+ * 1. figuring out whether the @p FOO, @p BAR, and @p BAZ expansions
+ *    are empty and adding a comma manually (or not) between FOR_EACH()
+ *    calls
+ * 2. rewriting SQUARE so it reacts appropriately when "x" is empty
+ *    (which would be necessary if e.g. @p FOO expands to nothing)
+ *
+ * @param F Macro to invoke on each nonempty element of the variable
+ *          arguments
+ * @param term Terminator (e.g. comma or semicolon) placed after each
+ *             invocation of F. Must be in parentheses; this is required
+ *             to enable providing a comma as separator.
+ * @param ... Variable argument list. The macro @p F is invoked as
+ *            <tt>F(element)</tt> for each nonempty element in the list.
+ */
+#define FOR_EACH_NONEMPTY_TERM(F, term, ...)				\
+	COND_CODE_0(							\
+		/* are there zero non-empty arguments ? */		\
+		NUM_VA_ARGS_LESS_1(LIST_DROP_EMPTY(__VA_ARGS__, _)),	\
+		/* if so, expand to nothing */				\
+		(),							\
+		/* otherwise, expand to: */				\
+		(/* FOR_EACH() on nonempty elements, */		\
+			FOR_EACH(F, term, LIST_DROP_EMPTY(__VA_ARGS__))	\
+			/* plus a final terminator */			\
+			__DEBRACKET term				\
+		))
+
+/**
+ * @brief Call macro @p F on each provided argument, with the argument's index
+ *        as an additional parameter.
+ *
+ * This is like FOR_EACH(), except @p F should be a macro which takes two
+ * arguments: <tt>F(index, variable_arg)</tt>.
+ *
+ * Example:
+ *
+ *     #define F(idx, x) int a##idx = x
+ *     FOR_EACH_IDX(F, (;), 4, 5, 6);
+ *
+ * This expands to:
+ *
+ *     int a0 = 4;
+ *     int a1 = 5;
+ *     int a2 = 6;
+ *
+ * @param F Macro to invoke
+ * @param sep Separator (e.g. comma or semicolon). Must be in parentheses;
+ *            this is required to enable providing a comma as separator.
+ * @param ... Variable argument list. The macro @p F is invoked as
+ *            <tt>F(index, element)</tt> for each element in the list.
+ */
+#define FOR_EACH_IDX(F, sep, ...) \
+	Z_FOR_EACH_IDX(F, sep, REVERSE_ARGS(__VA_ARGS__))
+
+/**
+ * @brief Call macro @p F on each provided argument, with an additional fixed
+ *	  argument as a parameter.
+ *
+ * This is like FOR_EACH(), except @p F should be a macro which takes two
+ * arguments: <tt>F(variable_arg, fixed_arg)</tt>.
+ *
+ * Example:
+ *
+ *     static void func(int val, void *dev);
+ *     FOR_EACH_FIXED_ARG(func, (;), dev, 4, 5, 6);
+ *
+ * This expands to:
+ *
+ *     func(4, dev);
+ *     func(5, dev);
+ *     func(6, dev);
+ *
+ * @param F Macro to invoke
+ * @param sep Separator (e.g. comma or semicolon). Must be in parentheses;
+ *            this is required to enable providing a comma as separator.
+ * @param fixed_arg Fixed argument passed to @p F as the second macro parameter.
+ * @param ... Variable argument list. The macro @p F is invoked as
+ *            <tt>F(element, fixed_arg)</tt> for each element in the list.
+ */
+#define FOR_EACH_FIXED_ARG(F, sep, fixed_arg, ...) \
+	Z_FOR_EACH_FIXED_ARG(F, sep, fixed_arg, REVERSE_ARGS(__VA_ARGS__))
+
+/**
+ * @brief Calls macro @p F for each variable argument with an index and fixed
+ *        argument
+ *
+ * This is like the combination of FOR_EACH_IDX() with FOR_EACH_FIXED_ARG().
+ *
+ * Example:
+ *
+ *     #define F(idx, x, fixed_arg) int fixed_arg##idx = x
+ *     FOR_EACH_IDX_FIXED_ARG(F, (;), a, 4, 5, 6);
+ *
+ * This expands to:
+ *
+ *     int a0 = 4;
+ *     int a1 = 5;
+ *     int a2 = 6;
+ *
+ * @param F Macro to invoke
+ * @param sep Separator (e.g. comma or semicolon). Must be in parentheses;
+ *            This is required to enable providing a comma as separator.
+ * @param fixed_arg Fixed argument passed to @p F as the third macro parameter.
+ * @param ... Variable list of arguments. The macro @p F is invoked as
+ *            <tt>F(index, element, fixed_arg)</tt> for each element in
+ *            the list.
+ */
+#define FOR_EACH_IDX_FIXED_ARG(F, sep, fixed_arg, ...) \
+	Z_FOR_EACH_IDX_FIXED_ARG(F, sep, fixed_arg, REVERSE_ARGS(__VA_ARGS__))
+
+/** @brief Reverse arguments order.
+ *
+ * @param ... Variable argument list.
+ */
+#define REVERSE_ARGS(...) \
+	Z_FOR_EACH_ENGINE(Z_FOR_EACH_EXEC, (,), Z_BYPASS, _, __VA_ARGS__)
+
+/**
+ * @brief Number of arguments in the variable arguments list minus one.
+ *
+ * @param ... List of arguments
+ * @return  Number of variadic arguments in the argument list, minus one
+ */
+#define NUM_VA_ARGS_LESS_1(...) \
+	NUM_VA_ARGS_LESS_1_IMPL(__VA_ARGS__, 63, 62, 61, \
+	60, 59, 58, 57, 56, 55, 54, 53, 52, 51,		 \
+	50, 49, 48, 47, 46, 45, 44, 43, 42, 41,		 \
+	40, 39, 38, 37, 36, 35, 34, 33, 32, 31,		 \
+	30, 29, 28, 27, 26, 25, 24, 23, 22, 21,		 \
+	20, 19, 18, 17, 16, 15, 14, 13, 12, 11,		 \
+	10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, ~)
+
+/**
+ * @brief Mapping macro that pastes results together
+ *
+ * This is similar to FOR_EACH() in that it invokes a macro repeatedly
+ * on each element of <tt>__VA_ARGS__</tt>. However, unlike FOR_EACH(),
+ * MACRO_MAP_CAT() pastes the results together into a single token.
+ *
+ * For example, with this macro FOO:
+ *
+ *     #define FOO(x) item_##x##_
+ *
+ * <tt>MACRO_MAP_CAT(FOO, a, b, c),</tt> expands to the token:
+ *
+ *     item_a_item_b_item_c_
+ *
+ * @param ... Macro to expand on each argument, followed by its
+ *            arguments. (The macro should take exactly one argument.)
+ * @return The results of expanding the macro on each argument, all pasted
+ *         together
+ */
+#define MACRO_MAP_CAT(...) MACRO_MAP_CAT_(__VA_ARGS__)
+
+/**
+ * @brief Mapping macro that pastes a fixed number of results together
+ *
+ * Similar to @ref MACRO_MAP_CAT(), but expects a fixed number of
+ * arguments. If more arguments are given than are expected, the rest
+ * are ignored.
+ *
+ * @param N   Number of arguments to map
+ * @param ... Macro to expand on each argument, followed by its
+ *            arguments. (The macro should take exactly one argument.)
+ * @return The results of expanding the macro on each argument, all pasted
+ *         together
+ */
+#define MACRO_MAP_CAT_N(N, ...) MACRO_MAP_CAT_N_(N, __VA_ARGS__)
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZEPHYR_INCLUDE_SYS_UTIL_MACROS_H_ */
diff --git a/framework/include/fwk_devicetree.h b/framework/include/fwk_devicetree.h
new file mode 100644
index 0000000000000000000000000000000000000000..a922dc54bf6decec429374ed0a142d279537287c
--- /dev/null
+++ b/framework/include/fwk_devicetree.h
@@ -0,0 +1,2655 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright (c) 2020 Nordic Semiconductor
+ * Copyright (c) 2020, Linaro Ltd.
+ *
+ * Copy of the devicetree.h file from Zephyr - with zephyr specific elements removed.
+ */
+#ifndef FWK_DEVICETREE_H
+#define FWK_DEVICETREE_H
+
+#include <dt_sys/util.h>
+
+/**
+ * @brief devicetree.h API
+ * @defgroup devicetree Devicetree
+ * @{
+ * @}
+ */
+
+/*
+ * Property suffixes
+ * -----------------
+ *
+ * These are the optional parts that come after the _P_<property>
+ * part in DT_N_<path-id>_P_<property-id> macros, or the "prop-suf"
+ * nonterminal in the DT guide's macros.bnf file.
+ *
+ * Before adding new ones, check this list to avoid conflicts. If any
+ * are missing from this list, please add them. It should be complete.
+ *
+ * _ENUM_IDX: property's value as an index into bindings enum
+ * _ENUM_TOKEN: property's value as a token into bindings enum (string
+ *              enum values are identifiers) [deprecated, use _STRING_TOKEN]
+ * _ENUM_UPPER_TOKEN: like _ENUM_TOKEN, but uppercased [deprecated, use
+ *		      _STRING_UPPER_TOKEN]
+ * _EXISTS: property is defined
+ * _FOREACH_PROP_ELEM: helper for "iterating" over values in the property
+ * _FOREACH_PROP_ELEM_VARGS: foreach functions with variable number of arguments
+ * _IDX_<i>: logical index into property
+ * _IDX_<i>_EXISTS: logical index into property is defined
+ * _IDX_<i>_PH: phandle array's phandle by index (or phandle, phandles)
+ * _IDX_<i>_VAL_<val>: phandle array's specifier value by index
+ * _IDX_<i>_VAL_<val>_EXISTS: cell value exists, by index
+ * _LEN: property logical length
+ * _NAME_<name>_PH: phandle array's phandle by name
+ * _NAME_<name>_VAL_<val>: phandle array's property specifier by name
+ * _NAME_<name>_VAL_<val>_EXISTS: cell value exists, by name
+ * _STRING_TOKEN: string property's value as a token
+ * _STRING_UPPER_TOKEN: like _STRING_TOKEN, but uppercased
+ */
+
+/**
+ * @defgroup devicetree-generic-id Node identifiers and helpers
+ * @ingroup devicetree
+ * @{
+ */
+
+/**
+ * @brief Name for an invalid node identifier
+ *
+ * This supports cases where factored macros can be invoked from paths where
+ * devicetree data may or may not be available.  It is a preprocessor identifier
+ * that does not match any valid devicetree node identifier.
+ */
+#define DT_INVALID_NODE _
+
+/**
+ * @brief Node identifier for the root node in the devicetree
+ */
+#define DT_ROOT DT_N
+
+/**
+ * @brief Get a node identifier for a devicetree path
+ *
+ * (This macro returns a node identifier from path components. To get
+ * a path string from a node identifier, use DT_NODE_PATH() instead.)
+ *
+ * The arguments to this macro are the names of non-root nodes in the
+ * tree required to reach the desired node, starting from the root.
+ * Non-alphanumeric characters in each name must be converted to
+ * underscores to form valid C tokens, and letters must be lowercased.
+ *
+ * Example devicetree fragment:
+ *
+ *     / {
+ *             soc {
+ *                     serial1: serial@40001000 {
+ *                             status = "okay";
+ *                             current-speed = <115200>;
+ *                             ...
+ *                     };
+ *             };
+ *     };
+ *
+ * You can use DT_PATH(soc, serial_40001000) to get a node identifier
+ * for the serial@40001000 node. Node labels like "serial1" cannot be
+ * used as DT_PATH() arguments; use DT_NODELABEL() for those instead.
+ *
+ * Example usage with DT_PROP() to get the current-speed property:
+ *
+ *     DT_PROP(DT_PATH(soc, serial_40001000), current_speed) // 115200
+ *
+ * (The current-speed property is also in "lowercase-and-underscores"
+ * form when used with this API.)
+ *
+ * When determining arguments to DT_PATH():
+ *
+ * - the first argument corresponds to a child node of the root ("soc" above)
+ * - a second argument corresponds to a child of the first argument
+ *   ("serial_40001000" above, from the node name "serial@40001000"
+ *   after lowercasing and changing "@" to "_")
+ * - and so on for deeper nodes in the desired node's path
+ *
+ * @param ... lowercase-and-underscores node names along the node's path,
+ *            with each name given as a separate argument
+ * @return node identifier for the node with that path
+ */
+#define DT_PATH(...) DT_PATH_INTERNAL(__VA_ARGS__)
+
+/**
+ * @brief Get a node identifier for a node label
+ *
+ * Convert non-alphanumeric characters in the node label to
+ * underscores to form valid C tokens, and lowercase all letters. Note
+ * that node labels are not the same thing as label properties.
+ *
+ * Example devicetree fragment:
+ *
+ *     serial1: serial@40001000 {
+ *             label = "UART_0";
+ *             status = "okay";
+ *             current-speed = <115200>;
+ *             ...
+ *     };
+ *
+ * The only node label in this example is "serial1".
+ *
+ * The string "UART_0" is *not* a node label; it's the value of a
+ * property named label.
+ *
+ * You can use DT_NODELABEL(serial1) to get a node identifier for the
+ * serial@40001000 node. Example usage with DT_PROP() to get the
+ * current-speed property:
+ *
+ *     DT_PROP(DT_NODELABEL(serial1), current_speed) // 115200
+ *
+ * Another example devicetree fragment:
+ *
+ *     cpu@0 {
+ *            L2_0: l2-cache {
+ *                    cache-level = <2>;
+ *                    ...
+ *            };
+ *     };
+ *
+ * Example usage to get the cache-level property:
+ *
+ *     DT_PROP(DT_NODELABEL(l2_0), cache_level) // 2
+ *
+ * Notice how "L2_0" in the devicetree is lowercased to "l2_0" in the
+ * DT_NODELABEL() argument.
+ *
+ * @param label lowercase-and-underscores node label name
+ * @return node identifier for the node with that label
+ */
+#define DT_NODELABEL(label) DT_CAT(DT_N_NODELABEL_, label)
+
+/**
+ * @brief Get a node identifier from /aliases
+ *
+ * This macro's argument is a property of the /aliases node. It
+ * returns a node identifier for the node which is aliased. Convert
+ * non-alphanumeric characters in the alias property to underscores to
+ * form valid C tokens, and lowercase all letters.
+ *
+ * Example devicetree fragment:
+ *
+ *     / {
+ *             aliases {
+ *                     my-serial = &serial1;
+ *             };
+ *
+ *             soc {
+ *                     serial1: serial@40001000 {
+ *                             status = "okay";
+ *                             current-speed = <115200>;
+ *                             ...
+ *                     };
+ *             };
+ *     };
+ *
+ * You can use DT_ALIAS(my_serial) to get a node identifier for the
+ * serial@40001000 node. Notice how my-serial in the devicetree
+ * becomes my_serial in the DT_ALIAS() argument. Example usage with
+ * DT_PROP() to get the current-speed property:
+ *
+ *     DT_PROP(DT_ALIAS(my_serial), current_speed) // 115200
+ *
+ * @param alias lowercase-and-underscores alias name.
+ * @return node identifier for the node with that alias
+ */
+#define DT_ALIAS(alias) DT_CAT(DT_N_ALIAS_, alias)
+
+/**
+ * @brief Get a node identifier for an instance of a compatible
+ *
+ * All nodes with a particular compatible property value are assigned
+ * instance numbers, which are zero-based indexes specific to that
+ * compatible. You can get a node identifier for these nodes by
+ * passing DT_INST() an instance number, "inst", along with the
+ * lowercase-and-underscores version of the compatible, "compat".
+ *
+ * Instance numbers have the following properties:
+ *
+ * - for each compatible, instance numbers start at 0 and are contiguous
+ * - exactly one instance number is assigned for each node with a compatible,
+ *   **including disabled nodes**
+ * - enabled nodes (status property is "okay" or missing) are assigned the
+ *   instance numbers starting from 0, and disabled nodes have instance
+ *   numbers which are greater than those of any enabled node
+ *
+ * No other guarantees are made. In particular:
+ *
+ * - instance numbers **in no way reflect** any numbering scheme that
+ *   might exist in SoC documentation, node labels or unit addresses,
+ *   or properties of the /aliases node (use DT_NODELABEL() or DT_ALIAS()
+ *   for those)
+ * - there **is no general guarantee** that the same node will have
+ *   the same instance number between builds, even if you are building
+ *   the same application again in the same build directory
+ *
+ * Example devicetree fragment:
+ *
+ *     serial1: serial@40001000 {
+ *             compatible = "vnd,soc-serial";
+ *             status = "disabled";
+ *             current-speed = <9600>;
+ *             ...
+ *     };
+ *
+ *     serial2: serial@40002000 {
+ *             compatible = "vnd,soc-serial";
+ *             status = "okay";
+ *             current-speed = <57600>;
+ *             ...
+ *     };
+ *
+ *     serial3: serial@40003000 {
+ *             compatible = "vnd,soc-serial";
+ *             current-speed = <115200>;
+ *             ...
+ *     };
+ *
+ * Assuming no other nodes in the devicetree have compatible
+ * "vnd,soc-serial", that compatible has nodes with instance numbers
+ * 0, 1, and 2.
+ *
+ * The nodes serial@40002000 and serial@40003000 are both enabled, so
+ * their instance numbers are 0 and 1, but no guarantees are made
+ * regarding which node has which instance number.
+ *
+ * Since serial@40001000 is the only disabled node, it has instance
+ * number 2, since disabled nodes are assigned the largest instance
+ * numbers. Therefore:
+ *
+ *     // Could be 57600 or 115200. There is no way to be sure:
+ *     // either serial@40002000 or serial@40003000 could
+ *     // have instance number 0, so this could be the current-speed
+ *     // property of either of those nodes.
+ *     DT_PROP(DT_INST(0, vnd_soc_serial), current_speed)
+ *
+ *     // Could be 57600 or 115200, for the same reason.
+ *     // If the above expression expands to 57600, then
+ *     // this expands to 115200, and vice-versa.
+ *     DT_PROP(DT_INST(1, vnd_soc_serial), current_speed)
+ *
+ *     // 9600, because there is only one disabled node, and
+ *     // disabled nodes are "at the the end" of the instance
+ *     // number "list".
+ *     DT_PROP(DT_INST(2, vnd_soc_serial), current_speed)
+ *
+ * Notice how "vnd,soc-serial" in the devicetree becomes vnd_soc_serial
+ * (without quotes) in the DT_INST() arguments. (As usual, current-speed
+ * in the devicetree becomes current_speed as well.)
+ *
+ * Nodes whose "compatible" property has multiple values are assigned
+ * independent instance numbers for each compatible.
+ *
+ * @param inst instance number for compatible "compat"
+ * @param compat lowercase-and-underscores compatible, without quotes
+ * @return node identifier for the node with that instance number and
+ *         compatible
+ */
+#define DT_INST(inst, compat) UTIL_CAT(DT_N_INST, DT_DASH(inst, compat))
+
+/**
+ * @brief Get a node identifier for a parent node
+ *
+ * Example devicetree fragment:
+ *
+ *     parent: parent-node {
+ *             child: child-node {
+ *                     ...
+ *             };
+ *     };
+ *
+ * The following are equivalent ways to get the same node identifier:
+ *
+ *     DT_NODELABEL(parent)
+ *     DT_PARENT(DT_NODELABEL(child))
+ *
+ * @param node_id node identifier
+ * @return a node identifier for the node's parent
+ */
+#define DT_PARENT(node_id) UTIL_CAT(node_id, _PARENT)
+
+/**
+ * @brief Get a node identifier for a grandparent node
+ *
+ * Example devicetree fragment:
+ *
+ *     gparent: grandparent-node {
+ *             parent: parent-node {
+ *                     child: child-node { ... }
+ *             };
+ *     };
+ *
+ * The following are equivalent ways to get the same node identifier:
+ *
+ *     DT_GPARENT(DT_NODELABEL(child))
+ *     DT_PARENT(DT_PARENT(DT_NODELABEL(child))
+ *
+ * @param node_id node identifier
+ * @return a node identifier for the node's parent's parent
+ */
+#define DT_GPARENT(node_id) DT_PARENT(DT_PARENT(node_id))
+
+/**
+ * @brief Get a node identifier for a child node
+ *
+ * Example devicetree fragment:
+ *
+ *     / {
+ *             soc-label: soc {
+ *                     serial1: serial@40001000 {
+ *                             status = "okay";
+ *                             current-speed = <115200>;
+ *                             ...
+ *                     };
+ *             };
+ *     };
+ *
+ * Example usage with @ref DT_PROP() to get the status of the
+ * serial@40001000 node:
+ *
+ *     #define SOC_NODE DT_NODELABEL(soc_label)
+ *     DT_PROP(DT_CHILD(SOC_NODE, serial_40001000), status) // "okay"
+ *
+ * Node labels like "serial1" cannot be used as the "child" argument
+ * to this macro. Use DT_NODELABEL() for that instead.
+ *
+ * You can also use DT_FOREACH_CHILD() to iterate over node
+ * identifiers for all of a node's children.
+ *
+ * @param node_id node identifier
+ * @param child lowercase-and-underscores child node name
+ * @return node identifier for the node with the name referred to by 'child'
+ */
+#define DT_CHILD(node_id, child) UTIL_CAT(node_id, DT_S_PREFIX(child))
+
+/**
+ * @brief Get a node identifier for a status "okay" node with a compatible
+ *
+ * Use this if you want to get an arbitrary enabled node with a given
+ * compatible, and you do not care which one you get. If any enabled
+ * nodes with the given compatible exist, a node identifier for one
+ * of them is returned. Otherwise, @p DT_INVALID_NODE is returned.
+ *
+ * Example devicetree fragment:
+ *
+ *	node-a {
+ *		compatible = "vnd,device";
+ *		status = "okay";
+ *	};
+ *
+ *	node-b {
+ *		compatible = "vnd,device";
+ *		status = "okay";
+ *	};
+ *
+ *	node-c {
+ *		compatible = "vnd,device";
+ *		status = "disabled";
+ *	};
+ *
+ * Example usage:
+ *
+ *     DT_COMPAT_GET_ANY_STATUS_OKAY(vnd_device)
+ *
+ * This expands to a node identifier for either @p node-a or @p
+ * node-b. It will not expand to a node identifier for @p node-c,
+ * because that node does not have status "okay".
+ *
+ * @param compat lowercase-and-underscores compatible, without quotes
+ * @return node identifier for a node with that compatible, or DT_INVALID_NODE
+ */
+#define DT_COMPAT_GET_ANY_STATUS_OKAY(compat)			\
+	COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(compat),	\
+		    (DT_INST(0, compat)),		\
+		    (DT_INVALID_NODE))
+
+/**
+ * @brief Get a devicetree node's full path as a string literal
+ *
+ * This returns the path to a node from a node identifier. To get a
+ * node identifier from path components instead, use DT_PATH().
+ *
+ * Example devicetree fragment:
+ *
+ *     / {
+ *             soc {
+ *                     node: my-node@12345678 { ... };
+ *             };
+ *     };
+ *
+ * Example usage:
+ *
+ *    DT_NODE_PATH(DT_NODELABEL(node)) // "/soc/my-node@12345678"
+ *    DT_NODE_PATH(DT_PATH(soc))       // "/soc"
+ *    DT_NODE_PATH(DT_ROOT)            // "/"
+ *
+ * @param node_id node identifier
+ * @return the node's full path in the devicetree
+ */
+#define DT_NODE_PATH(node_id) DT_CAT(node_id, _PATH)
+
+/**
+ * @brief Get a devicetree node's name with unit-address as a string literal
+ *
+ * This returns the node name and unit-address from a node identifier.
+ *
+ * Example devicetree fragment:
+ *
+ *     / {
+ *             soc {
+ *                     node: my-node@12345678 { ... };
+ *             };
+ *     };
+ *
+ * Example usage:
+ *
+ *    DT_NODE_FULL_NAME(DT_NODELABEL(node)) // "my-node@12345678"
+ *
+ * @param node_id node identifier
+ * @return the node's name with unit-address as a string in the devicetree
+ */
+#define DT_NODE_FULL_NAME(node_id) DT_CAT(node_id, _FULL_NAME)
+
+/**
+ * @brief Do node_id1 and node_id2 refer to the same node?
+ *
+ * Both "node_id1" and "node_id2" must be node identifiers for nodes
+ * that exist in the devicetree (if unsure, you can check with
+ * DT_NODE_EXISTS()).
+ *
+ * The expansion evaluates to 0 or 1, but may not be a literal integer
+ * 0 or 1.
+ *
+ * @param node_id1 first node identifer
+ * @param node_id2 second node identifier
+ * @return an expression that evaluates to 1 if the node identifiers
+ *         refer to the same node, and evaluates to 0 otherwise
+ */
+#define DT_SAME_NODE(node_id1, node_id2) \
+	(DT_DEP_ORD(node_id1) == (DT_DEP_ORD(node_id2)))
+
+/* Implementation note: distinct nodes have distinct node identifiers.
+ * See include/devicetree/ordinals.h. */
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup devicetree-generic-prop Property accessors
+ * @ingroup devicetree
+ * @{
+ */
+
+/**
+ * @brief Get a devicetree property value
+ *
+ * For properties whose bindings have the following types, this macro
+ * expands to:
+ *
+ * - string: a string literal
+ * - boolean: 0 if the property is false, or 1 if it is true
+ * - int: the property's value as an integer literal
+ * - array, uint8-array, string-array: an initializer expression in braces,
+ *   whose elements are integer or string literals (like {0, 1, 2},
+ *   {"hello", "world"}, etc.)
+ * - phandle: a node identifier for the node with that phandle
+ *
+ * A property's type is usually defined by its binding. In some
+ * special cases, it has an assumed type defined by the devicetree
+ * specification even when no binding is available: "compatible" has
+ * type string-array, "status" and "label" have type string, and
+ * "interrupt-controller" has type boolean.
+ *
+ * For other properties or properties with unknown type due to a
+ * missing binding, behavior is undefined.
+ *
+ * For usage examples, see @ref DT_PATH(), @ref DT_ALIAS(), @ref
+ * DT_NODELABEL(), and @ref DT_INST() above.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property name
+ * @return a representation of the property's value
+ */
+#define DT_PROP(node_id, prop) DT_CAT(node_id, _P_##prop)
+
+/**
+ * @brief Get a property's logical length
+ *
+ * Here, "length" is a number of elements, which may differ from the
+ * property's size in bytes.
+ *
+ * The return value depends on the property's type:
+ *
+ * - for types array, string-array, and uint8-array, this expands
+ *   to the number of elements in the array
+ * - for type phandles, this expands to the number of phandles
+ * - for type phandle-array, this expands to the number of
+ *   phandle and specifier blocks in the property
+ *
+ * These properties are handled as special cases:
+ *
+ * - reg property: use DT_NUM_REGS(node_id) instead
+ * - interrupts property: use DT_NUM_IRQS(node_id) instead
+ *
+ * It is an error to use this macro with the reg or interrupts properties.
+ *
+ * For other properties, behavior is undefined.
+ *
+ * @param node_id node identifier
+ * @param prop a lowercase-and-underscores property with a logical length
+ * @return the property's length
+ */
+#define DT_PROP_LEN(node_id, prop) DT_PROP(node_id, prop##_LEN)
+
+/**
+ * @brief Like DT_PROP_LEN(), but with a fallback to default_value
+ *
+ * If the property is defined (as determined by DT_NODE_HAS_PROP()),
+ * this expands to DT_PROP_LEN(node_id, prop). The default_value
+ * parameter is not expanded in this case.
+ *
+ * Otherwise, this expands to default_value.
+ *
+ * @param node_id node identifier
+ * @param prop a lowercase-and-underscores property with a logical length
+ * @param default_value a fallback value to expand to
+ * @return the property's length or the given default value
+ */
+#define DT_PROP_LEN_OR(node_id, prop, default_value) \
+	COND_CODE_1(DT_NODE_HAS_PROP(node_id, prop), \
+		    (DT_PROP_LEN(node_id, prop)), (default_value))
+
+/**
+ * @brief Is index "idx" valid for an array type property?
+ *
+ * If this returns 1, then DT_PROP_BY_IDX(node_id, prop, idx) or
+ * DT_PHA_BY_IDX(node_id, prop, idx, ...) are valid at index "idx".
+ * If it returns 0, it is an error to use those macros with that index.
+ *
+ * These properties are handled as special cases:
+ *
+ * - reg property: use DT_REG_HAS_IDX(node_id, idx) instead
+ * - interrupts property: use DT_IRQ_HAS_IDX(node_id, idx) instead
+ *
+ * It is an error to use this macro with the reg or interrupts properties.
+ *
+ * @param node_id node identifier
+ * @param prop a lowercase-and-underscores property with a logical length
+ * @param idx index to check
+ * @return An expression which evaluates to 1 if "idx" is a valid index
+ *         into the given property, and 0 otherwise.
+ */
+#define DT_PROP_HAS_IDX(node_id, prop, idx) \
+	IS_ENABLED(DT_CAT6(node_id, _P_, prop, _IDX_, idx, _EXISTS))
+
+/**
+ * @brief Get the value at index "idx" in an array type property
+ *
+ * It might help to read the argument order as being similar to
+ * "node->property[index]".
+ *
+ * When the property's binding has type array, string-array,
+ * uint8-array, or phandles, this expands to the idx-th array element
+ * as an integer, string literal, or node identifier respectively.
+ *
+ * These properties are handled as special cases:
+ *
+ * - reg property: use DT_REG_ADDR_BY_IDX() or DT_REG_SIZE_BY_IDX() instead
+ * - interrupts property: use DT_IRQ_BY_IDX() instead
+ *
+ * For non-array properties, behavior is undefined.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property name
+ * @param idx the index to get
+ * @return a representation of the idx-th element of the property
+ */
+#define DT_PROP_BY_IDX(node_id, prop, idx) DT_PROP(node_id, prop##_IDX_##idx)
+
+/**
+ * @brief Like DT_PROP(), but with a fallback to default_value
+ *
+ * If the value exists, this expands to DT_PROP(node_id, prop).
+ * The default_value parameter is not expanded in this case.
+ *
+ * Otherwise, this expands to default_value.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property name
+ * @param default_value a fallback value to expand to
+ * @return the property's value or default_value
+ */
+#define DT_PROP_OR(node_id, prop, default_value) \
+	COND_CODE_1(DT_NODE_HAS_PROP(node_id, prop), \
+		    (DT_PROP(node_id, prop)), (default_value))
+
+/**
+ * @brief Equivalent to DT_PROP(node_id, label)
+ *
+ * This is a convenience for the Zephyr device API, which uses label
+ * properties as device_get_binding() arguments.
+ * @param node_id node identifier
+ * @return node's label property value
+ */
+#define DT_LABEL(node_id) DT_PROP(node_id, label)
+
+/**
+ * @brief Get a property value's index into its enumeration values
+ *
+ * The return values start at zero.
+ *
+ * Example devicetree fragment:
+ *
+ *     usb1: usb@12340000 {
+ *             maximum-speed = "full-speed";
+ *     };
+ *     usb2: usb@12341000 {
+ *             maximum-speed = "super-speed";
+ *     };
+ *
+ * Example bindings fragment:
+ *
+ *     properties:
+ *       maximum-speed:
+ *         type: string
+ *         enum:
+ *            - "low-speed"
+ *            - "full-speed"
+ *            - "high-speed"
+ *            - "super-speed"
+ *
+ * Example usage:
+ *
+ *     DT_ENUM_IDX(DT_NODELABEL(usb1), maximum_speed) // 1
+ *     DT_ENUM_IDX(DT_NODELABEL(usb2), maximum_speed) // 3
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property name
+ * @return zero-based index of the property's value in its enum: list
+ */
+#define DT_ENUM_IDX(node_id, prop) DT_PROP(node_id, prop##_ENUM_IDX)
+
+/**
+ * @brief Like DT_ENUM_IDX(), but with a fallback to a default enum index
+ *
+ * If the value exists, this expands to its zero based index value thanks to
+ * DT_ENUM_IDX(node_id, prop).
+ *
+ * Otherwise, this expands to provided default index enum value.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property name
+ * @param default_idx_value a fallback index value to expand to
+ * @return zero-based index of the property's value in its enum if present,
+ *         default_idx_value ohterwise
+ */
+#define DT_ENUM_IDX_OR(node_id, prop, default_idx_value) \
+	COND_CODE_1(DT_NODE_HAS_PROP(node_id, prop), \
+		    (DT_ENUM_IDX(node_id, prop)), (default_idx_value))
+
+/**
+ * @brief Get a string property's value as a token.
+ *
+ * This removes "the quotes" from string-valued properties, and converts
+ * non-alphanumeric characters to underscores. That can be useful, for example,
+ * when programmatically using the value to form a C variable or code.
+ *
+ * DT_STRING_TOKEN() can only be used for properties with string type.
+ *
+ * It is an error to use DT_STRING_TOKEN() in other circumstances.
+ *
+ * Example devicetree fragment:
+ *
+ *     n1: node-1 {
+ *             prop = "foo";
+ *     };
+ *     n2: node-2 {
+ *             prop = "FOO";
+ *     }
+ *     n3: node-3 {
+ *             prop = "123 foo";
+ *     };
+ *
+ * Example bindings fragment:
+ *
+ *     properties:
+ *       prop:
+ *         type: string
+ *
+ * Example usage:
+ *
+ *     DT_STRING_TOKEN(DT_NODELABEL(n1), prop) // foo
+ *     DT_STRING_TOKEN(DT_NODELABEL(n2), prop) // FOO
+ *     DT_STRING_TOKEN(DT_NODELABEL(n3), prop) // 123_foo
+ *
+ * Notice how:
+ *
+ * - Unlike C identifiers, the property values may begin with a
+ *   number. It's the user's responsibility not to use such values as
+ *   the name of a C identifier.
+ *
+ * - The uppercased "FOO" in the DTS remains @p FOO as a token. It is
+ *   *not* converted to @p foo.
+ *
+ * - The whitespace in the DTS "123 foo" string is converted to @p
+ *   123_foo as a token.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property string name
+ * @return the value of @p prop as a token, i.e. without any quotes
+ *         and with special characters converted to underscores
+ */
+#define DT_STRING_TOKEN(node_id, prop) \
+	DT_CAT4(node_id, _P_, prop, _STRING_TOKEN)
+
+/**
+ * @brief Like DT_STRING_TOKEN(), but uppercased.
+ *
+ * This removes "the quotes and capitalize" from string-valued properties, and
+ * converts non-alphanumeric characters to underscores. That can be useful, for
+ * example, when programmatically using the value to form a C variable or code.
+ *
+ * DT_STRING_UPPER_TOKEN() can only be used for properties with string type.
+ *
+ * It is an error to use DT_STRING_UPPER_TOKEN() in other circumstances.
+ *
+ * Example devicetree fragment:
+ *
+ *     n1: node-1 {
+ *             prop = "foo";
+ *     };
+ *     n2: node-2 {
+ *             prop = "123 foo";
+ *     };
+ *
+ * Example bindings fragment:
+ *
+ *     properties:
+ *       prop:
+ *         type: string
+ *
+ * Example usage:
+ *
+ *     DT_STRING_UPPER_TOKEN(DT_NODELABEL(n1), prop) // FOO
+ *     DT_STRING_UPPER_TOKEN(DT_NODELABEL(n2), prop) // 123_FOO
+ *
+ * Notice how:
+ *
+ * - Unlike C identifiers, the property values may begin with a
+ *   number. It's the user's responsibility not to use such values as
+ *   the name of a C identifier.
+ *
+ * - The lowercased "foo" in the DTS becomes @p FOO as a token, i.e.
+ *   it is uppercased.
+ *
+ * - The whitespace in the DTS "123 foo" string is converted to @p
+ *   123_FOO as a token, i.e. it is uppercased and whitespace becomes
+ *   an underscore.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property string name
+ * @return the value of @p prop as a token, i.e. without any quotes
+ *         and with special characters converted to underscores
+ */
+#define DT_STRING_UPPER_TOKEN(node_id, prop) \
+	DT_CAT4(node_id, _P_, prop, _STRING_UPPER_TOKEN)
+
+/**
+ * @brief Get an enumeration property's value as a token.
+ *
+ * This allows you to "remove the quotes" from some string-valued
+ * properties. That can be useful, for example, when pasting the
+ * values onto some other token to form an enum in C using the @p ##
+ * preprocessor operator.
+ *
+ * DT_ENUM_TOKEN() can only be used for properties with string type
+ * whose binding has an "enum:". The values in the binding's "enum:"
+ * list must be unique after converting non-alphanumeric characters to
+ * underscores.
+ *
+ * It is an error to use DT_ENUM_TOKEN() in other circumstances.
+ *
+ * Example devicetree fragment:
+ *
+ *     n1: node-1 {
+ *             prop = "foo";
+ *     };
+ *     n2: node-2 {
+ *             prop = "FOO";
+ *     }
+ *     n3: node-3 {
+ *             prop = "123 foo";
+ *     };
+ *
+ * Example bindings fragment:
+ *
+ *     properties:
+ *       prop:
+ *         type: string
+ *         enum:
+ *            - "foo"
+ *            - "FOO"
+ *            - "123 foo"
+ *
+ * Example usage:
+ *
+ *     DT_ENUM_TOKEN(DT_NODELABEL(n1), prop) // foo
+ *     DT_ENUM_TOKEN(DT_NODELABEL(n2), prop) // FOO
+ *     DT_ENUM_TOKEN(DT_NODELABEL(n3), prop) // 123_foo
+ *
+ * Notice how:
+ *
+ * - Unlike C identifiers, the property values may begin with a
+ *   number. It's the user's responsibility not to use such values as
+ *   the name of a C identifier.
+ *
+ * - The uppercased "FOO" in the DTS remains @p FOO as a token. It is
+     *not* converted to @p foo.
+ *
+ * - The whitespace in the DTS "123 foo" string is converted to @p
+ *   123_foo as a token.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property name with suitable
+ *             enumeration of values in its binding
+ * @return the value of @p prop as a token, i.e. without any quotes
+ *         and with special characters converted to underscores
+ */
+#define DT_ENUM_TOKEN(node_id, prop) \
+	__DEPRECATED_MACRO \
+	DT_CAT4(node_id, _P_, prop, _ENUM_TOKEN)
+
+/**
+ * @brief Like DT_ENUM_TOKEN(), but uppercased
+ *
+ * This allows you to "remove the quotes and capitalize" some string-valued
+ * properties.
+ *
+ * DT_ENUM_UPPER_TOKEN() can only be used for properties with string type
+ * whose binding has an "enum:". The values in the binding's "enum:"
+ * list must be unique after converting non-alphanumeric characters to
+ * underscores and capitalizating any letters.
+ *
+ * It is an error to use DT_ENUM_UPPER_TOKEN() in other circumstances.
+ *
+ * Example devicetree fragment:
+ *
+ *     n1: node-1 {
+ *             prop = "foo";
+ *     };
+ *     n2: node-2 {
+ *             prop = "123 foo";
+ *     };
+ *
+ * Example bindings fragment:
+ *
+ *     properties:
+ *       prop:
+ *         type: string
+ *         enum:
+ *            - "foo"
+ *            - "123 foo"
+ *
+ * Example usage:
+ *
+ *     DT_ENUM_TOKEN((DT_NODELABEL(n1), prop) // FOO
+ *     DT_ENUM_TOKEN((DT_NODELABEL(n2), prop) // 123_FOO
+ *
+ * Notice how:
+ *
+ * - Unlike C identifiers, the property values may begin with a
+ *   number. It's the user's responsibility not to use such values as
+ *   the name of a C identifier.
+ *
+ * - The lowercased "foo" in the DTS becomes @p FOO as a token, i.e.
+ *   it is uppercased.
+ *
+ * - The whitespace in the DTS "123 foo" string is converted to @p
+ *   123_FOO as a token, i.e. it is uppercased and whitespace becomes
+ *   an underscore.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property name with suitable
+ *             enumeration of values in its binding
+ * @return the value of @p prop as a capitalized token, i.e. upper case,
+ *         without any quotes, and with special characters converted to
+ *         underscores
+ */
+#define DT_ENUM_UPPER_TOKEN(node_id, prop) \
+	__DEPRECATED_MACRO \
+	DT_CAT4(node_id, _P_, prop, _ENUM_UPPER_TOKEN)
+
+/*
+ * phandle properties
+ *
+ * These are special-cased to manage the impedance mismatch between
+ * phandles, which are just uint32_t node properties that only make sense
+ * within the tree itself, and C values.
+ */
+
+/**
+ * @brief Get a property value from a phandle in a property.
+ *
+ * This is a shorthand for:
+ *
+ *     DT_PROP(DT_PHANDLE_BY_IDX(node_id, phs, idx), prop)
+ *
+ * That is, "prop" is a property of the phandle's node, not a
+ * property of "node_id".
+ *
+ * Example devicetree fragment:
+ *
+ *     n1: node-1 {
+ *             foo = <&n2 &n3>;
+ *     };
+ *
+ *     n2: node-2 {
+ *             bar = <42>;
+ *     };
+ *
+ *     n3: node-3 {
+ *             baz = <43>;
+ *     };
+ *
+ * Example usage:
+ *
+ *     #define N1 DT_NODELABEL(n1)
+ *
+ *     DT_PROP_BY_PHANDLE_IDX(N1, foo, 0, bar) // 42
+ *     DT_PROP_BY_PHANDLE_IDX(N1, foo, 1, baz) // 43
+ *
+ * @param node_id node identifier
+ * @param phs lowercase-and-underscores property with type "phandle",
+ *            "phandles", or "phandle-array"
+ * @param idx logical index into "phs", which must be zero if "phs"
+ *            has type "phandle"
+ * @param prop lowercase-and-underscores property of the phandle's node
+ * @return the property's value
+ */
+#define DT_PROP_BY_PHANDLE_IDX(node_id, phs, idx, prop) \
+	DT_PROP(DT_PHANDLE_BY_IDX(node_id, phs, idx), prop)
+
+/**
+ * @brief Like DT_PROP_BY_PHANDLE_IDX(), but with a fallback to
+ * default_value.
+ *
+ * If the value exists, this expands to DT_PROP_BY_PHANDLE_IDX(node_id, phs,
+ * idx, prop). The default_value parameter is not expanded in this
+ * case.
+ *
+ * Otherwise, this expands to default_value.
+ *
+ * @param node_id node identifier
+ * @param phs lowercase-and-underscores property with type "phandle",
+ *            "phandles", or "phandle-array"
+ * @param idx logical index into "phs", which must be zero if "phs"
+ *            has type "phandle"
+ * @param prop lowercase-and-underscores property of the phandle's node
+ * @param default_value a fallback value to expand to
+ * @return the property's value
+ */
+#define DT_PROP_BY_PHANDLE_IDX_OR(node_id, phs, idx, prop, default_value) \
+	DT_PROP_OR(DT_PHANDLE_BY_IDX(node_id, phs, idx), prop, default_value)
+
+/**
+ * @brief Get a property value from a phandle's node
+ *
+ * This is equivalent to DT_PROP_BY_PHANDLE_IDX(node_id, ph, 0, prop).
+ *
+ * @param node_id node identifier
+ * @param ph lowercase-and-underscores property of "node_id"
+ *           with type "phandle"
+ * @param prop lowercase-and-underscores property of the phandle's node
+ * @return the property's value
+ */
+#define DT_PROP_BY_PHANDLE(node_id, ph, prop) \
+	DT_PROP_BY_PHANDLE_IDX(node_id, ph, 0, prop)
+
+/**
+ * @brief Get a phandle-array specifier cell value at an index
+ *
+ * It might help to read the argument order as being similar to
+ * "node->phandle_array[index].cell". That is, the cell value is in
+ * the "pha" property of "node_id", inside the specifier at index
+ * "idx".
+ *
+ * Example devicetree fragment:
+ *
+ *     gpio0: gpio@... {
+ *             #gpio-cells = <2>;
+ *     };
+ *
+ *     gpio1: gpio@... {
+ *             #gpio-cells = <2>;
+ *     };
+ *
+ *     led: led_0 {
+ *             gpios = <&gpio0 17 0x1>, <&gpio1 5 0x3>;
+ *     };
+ *
+ * Bindings fragment for the gpio0 and gpio1 nodes:
+ *
+ *     gpio-cells:
+ *       - pin
+ *       - flags
+ *
+ * Above, "gpios" has two elements:
+ *
+ * - index 0 has specifier <17 0x1>, so its "pin" cell is 17, and its
+ *   "flags" cell is 0x1
+ * - index 1 has specifier <5 0x3>, so "pin" is 5 and "flags" is 0x3
+ *
+ * Example usage:
+ *
+ *     #define LED DT_NODELABEL(led)
+ *
+ *     DT_PHA_BY_IDX(LED, gpios, 0, pin)   // 17
+ *     DT_PHA_BY_IDX(LED, gpios, 1, flags) // 0x3
+ *
+ * @param node_id node identifier
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param idx logical index into "pha"
+ * @param cell lowercase-and-underscores cell name within the specifier
+ *             at "pha" index "idx"
+ * @return the cell's value
+ */
+#define DT_PHA_BY_IDX(node_id, pha, idx, cell) \
+	DT_PROP(node_id, pha##_IDX_##idx##_VAL_##cell)
+
+/**
+ * @brief Like DT_PHA_BY_IDX(), but with a fallback to default_value.
+ *
+ * If the value exists, this expands to DT_PHA_BY_IDX(node_id, pha,
+ * idx, cell). The default_value parameter is not expanded in this
+ * case.
+ *
+ * Otherwise, this expands to default_value.
+ *
+ * @param node_id node identifier
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param idx logical index into "pha"
+ * @param cell lowercase-and-underscores cell name within the specifier
+ *             at "pha" index "idx"
+ * @param default_value a fallback value to expand to
+ * @return the cell's value or "default_value"
+ */
+#define DT_PHA_BY_IDX_OR(node_id, pha, idx, cell, default_value) \
+	DT_PROP_OR(node_id, pha##_IDX_##idx##_VAL_##cell, default_value)
+/* Implementation note: the _IDX_##idx##_VAL_##cell##_EXISTS
+ * macros are defined, so it's safe to use DT_PROP_OR() here, because
+ * that uses an IS_ENABLED() on the _EXISTS macro.
+ */
+
+/**
+ * @brief Equivalent to DT_PHA_BY_IDX(node_id, pha, 0, cell)
+ * @param node_id node identifier
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param cell lowercase-and-underscores cell name
+ * @return the cell's value
+ */
+#define DT_PHA(node_id, pha, cell) DT_PHA_BY_IDX(node_id, pha, 0, cell)
+
+/**
+ * @brief Like DT_PHA(), but with a fallback to default_value
+ *
+ * If the value exists, this expands to DT_PHA(node_id, pha, cell).
+ * The default_value parameter is not expanded in this case.
+ *
+ * Otherwise, this expands to default_value.
+ *
+ * @param node_id node identifier
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param cell lowercase-and-underscores cell name
+ * @param default_value a fallback value to expand to
+ * @return the cell's value or default_value
+ */
+#define DT_PHA_OR(node_id, pha, cell, default_value) \
+	DT_PHA_BY_IDX_OR(node_id, pha, 0, cell, default_value)
+
+/**
+ * @brief Get a value within a phandle-array specifier by name
+ *
+ * This is like DT_PHA_BY_IDX(), except it treats "pha" as a structure
+ * where each array element has a name.
+ *
+ * It might help to read the argument order as being similar to
+ * "node->phandle_struct.name.cell". That is, the cell value is in the
+ * "pha" property of "node_id", treated as a data structure where
+ * each array element has a name.
+ *
+ * Example devicetree fragment:
+ *
+ *     n: node {
+ *             io-channels = <&adc1 10>, <&adc2 20>;
+ *             io-channel-names = "SENSOR", "BANDGAP";
+ *     };
+ *
+ * Bindings fragment for the "adc1" and "adc2" nodes:
+ *
+ *     io-channel-cells:
+ *       - input
+ *
+ * Example usage:
+ *
+ *     DT_PHA_BY_NAME(DT_NODELABEL(n), io_channels, sensor, input)  // 10
+ *     DT_PHA_BY_NAME(DT_NODELABEL(n), io_channels, bandgap, input) // 20
+ *
+ * @param node_id node identifier
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param name lowercase-and-underscores name of a specifier in "pha"
+ * @param cell lowercase-and-underscores cell name in the named specifier
+ * @return the cell's value
+ */
+#define DT_PHA_BY_NAME(node_id, pha, name, cell) \
+	DT_PROP(node_id, pha##_NAME_##name##_VAL_##cell)
+
+/**
+ * @brief Like DT_PHA_BY_NAME(), but with a fallback to default_value
+ *
+ * If the value exists, this expands to DT_PHA_BY_NAME(node_id, pha,
+ * name, cell). The default_value parameter is not expanded in this case.
+ *
+ * Otherwise, this expands to default_value.
+ *
+ * @param node_id node identifier
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param name lowercase-and-underscores name of a specifier in "pha"
+ * @param cell lowercase-and-underscores cell name in the named specifier
+ * @param default_value a fallback value to expand to
+ * @return the cell's value or default_value
+ */
+#define DT_PHA_BY_NAME_OR(node_id, pha, name, cell, default_value) \
+	DT_PROP_OR(node_id, pha##_NAME_##name##_VAL_##cell, default_value)
+/* Implementation note: the _NAME_##name##_VAL_##cell##_EXISTS
+ * macros are defined, so it's safe to use DT_PROP_OR() here, because
+ * that uses an IS_ENABLED() on the _EXISTS macro.
+ */
+
+/**
+ * @brief Get a phandle's node identifier from a phandle array by name
+ *
+ * It might help to read the argument order as being similar to
+ * "node->phandle_struct.name.phandle". That is, the phandle array is
+ * treated as a structure with named elements. The return value is
+ * the node identifier for a phandle inside the structure.
+ *
+ * Example devicetree fragment:
+ *
+ *     adc1: adc@... {
+ *             label = "ADC_1";
+ *     };
+ *
+ *     adc2: adc@... {
+ *             label = "ADC_2";
+ *     };
+ *
+ *     n: node {
+ *             io-channels = <&adc1 10>, <&adc2 20>;
+ *             io-channel-names = "SENSOR", "BANDGAP";
+ *     };
+ *
+ * Above, "io-channels" has two elements:
+ *
+ * - the element named "SENSOR" has phandle &adc1
+ * - the element named "BANDGAP" has phandle &adc2
+ *
+ * Example usage:
+ *
+ *     #define NODE DT_NODELABEL(n)
+ *
+ *     DT_LABEL(DT_PHANDLE_BY_NAME(NODE, io_channels, sensor))  // "ADC_1"
+ *     DT_LABEL(DT_PHANDLE_BY_NAME(NODE, io_channels, bandgap)) // "ADC_2"
+ *
+ * Notice how devicetree properties and names are lowercased, and
+ * non-alphanumeric characters are converted to underscores.
+ *
+ * @param node_id node identifier
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param name lowercase-and-underscores name of an element in "pha"
+ * @return a node identifier for the node with that phandle
+ */
+#define DT_PHANDLE_BY_NAME(node_id, pha, name) \
+	DT_PROP(node_id, pha##_NAME_##name##_PH)
+
+/**
+ * @brief Get a node identifier for a phandle in a property.
+ *
+ * When a node's value at a logical index contains a phandle, this
+ * macro returns a node identifier for the node with that phandle.
+ *
+ * Therefore, if "prop" has type "phandle", "idx" must be zero. (A
+ * "phandle" type is treated as a "phandles" with a fixed length of
+ * 1).
+ *
+ * Example devicetree fragment:
+ *
+ *     n1: node-1 {
+ *             foo = <&n2 &n3>;
+ *     };
+ *
+ *     n2: node-2 { ... };
+ *     n3: node-3 { ... };
+ *
+ * Above, "foo" has type phandles and has two elements:
+ *
+ * - index 0 has phandle &n2, which is node-2's phandle
+ * - index 1 has phandle &n3, which is node-3's phandle
+ *
+ * Example usage:
+ *
+ *     #define N1 DT_NODELABEL(n1)
+ *
+ *     DT_PHANDLE_BY_IDX(N1, foo, 0) // node identifier for node-2
+ *     DT_PHANDLE_BY_IDX(N1, foo, 1) // node identifier for node-3
+ *
+ * Behavior is analogous for phandle-arrays.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property name in "node_id"
+ *             with type "phandle", "phandles" or "phandle-array"
+ * @param idx index into "prop"
+ * @return node identifier for the node with the phandle at that index
+ */
+#define DT_PHANDLE_BY_IDX(node_id, prop, idx) \
+	DT_CAT6(node_id, _P_, prop, _IDX_, idx, _PH)
+/*
+ * Implementation note: using DT_CAT6 above defers concatenation until
+ * after expansion of each parameter. This is important when 'idx' is
+ * expandable to a number, but it isn't one "yet".
+ */
+
+/**
+ * @brief Get a node identifier for a phandle property's value
+ *
+ * This is equivalent to DT_PHANDLE_BY_IDX(node_id, prop, 0). Its primary
+ * benefit is readability when "prop" has type "phandle".
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property of "node_id"
+ *             with type "phandle"
+ * @return a node identifier for the node pointed to by "ph"
+ */
+#define DT_PHANDLE(node_id, prop) DT_PHANDLE_BY_IDX(node_id, prop, 0)
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup devicetree-reg-prop reg property
+ * @ingroup devicetree
+ * @{
+ */
+
+/**
+ * @brief Get the number of register blocks in the reg property
+ *
+ * Use this instead of DT_PROP_LEN(node_id, reg).
+ * @param node_id node identifier
+ * @return Number of register blocks in the node's "reg" property.
+ */
+#define DT_NUM_REGS(node_id) DT_CAT(node_id, _REG_NUM)
+
+/**
+ * @brief Is "idx" a valid register block index?
+ *
+ * If this returns 1, then DT_REG_ADDR_BY_IDX(node_id, idx) or
+ * DT_REG_SIZE_BY_IDX(node_id, idx) are valid.
+ * If it returns 0, it is an error to use those macros with index "idx".
+ * @param node_id node identifier
+ * @param idx index to check
+ * @return 1 if "idx" is a valid register block index,
+ *         0 otherwise.
+ */
+#define DT_REG_HAS_IDX(node_id, idx) \
+	IS_ENABLED(DT_CAT(node_id, _REG_IDX_##idx##_EXISTS))
+
+/**
+ * @brief Get the base address of the register block at index "idx"
+ * @param node_id node identifier
+ * @param idx index of the register whose address to return
+ * @return address of the idx-th register block
+ */
+#define DT_REG_ADDR_BY_IDX(node_id, idx) \
+	DT_CAT(node_id, _REG_IDX_##idx##_VAL_ADDRESS)
+
+/**
+ * @brief Get the size of the register block at index "idx"
+ *
+ * This is the size of an individual register block, not the total
+ * number of register blocks in the property; use DT_NUM_REGS() for
+ * that.
+ *
+ * @param node_id node identifier
+ * @param idx index of the register whose size to return
+ * @return size of the idx-th register block
+ */
+#define DT_REG_SIZE_BY_IDX(node_id, idx) \
+	DT_CAT(node_id, _REG_IDX_##idx##_VAL_SIZE)
+
+/**
+ * @brief Get a node's (only) register block address
+ *
+ * Equivalent to DT_REG_ADDR_BY_IDX(node_id, 0).
+ * @param node_id node identifier
+ * @return node's register block address
+ */
+#define DT_REG_ADDR(node_id) DT_REG_ADDR_BY_IDX(node_id, 0)
+
+/**
+ * @brief Get a node's (only) register block size
+ *
+ * Equivalent to DT_REG_SIZE_BY_IDX(node_id, 0).
+ * @param node_id node identifier
+ * @return node's only register block's size
+ */
+#define DT_REG_SIZE(node_id) DT_REG_SIZE_BY_IDX(node_id, 0)
+
+/**
+ * @brief Get a register block's base address by name
+ * @param node_id node identifier
+ * @param name lowercase-and-underscores register specifier name
+ * @return address of the register block specified by name
+ */
+#define DT_REG_ADDR_BY_NAME(node_id, name) \
+	DT_CAT(node_id, _REG_NAME_##name##_VAL_ADDRESS)
+
+/**
+ * @brief Get a register block's size by name
+ * @param node_id node identifier
+ * @param name lowercase-and-underscores register specifier name
+ * @return size of the register block specified by name
+ */
+#define DT_REG_SIZE_BY_NAME(node_id, name) \
+	DT_CAT(node_id, _REG_NAME_##name##_VAL_SIZE)
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup devicetree-interrupts-prop interrupts property
+ * @ingroup devicetree
+ * @{
+ */
+
+/**
+ * @brief Get the number of interrupt sources for the node
+ *
+ * Use this instead of DT_PROP_LEN(node_id, interrupts).
+ *
+ * @param node_id node identifier
+ * @return Number of interrupt specifiers in the node's "interrupts" property.
+ */
+#define DT_NUM_IRQS(node_id) DT_CAT(node_id, _IRQ_NUM)
+
+/**
+ * @brief Is "idx" a valid interrupt index?
+ *
+ * If this returns 1, then DT_IRQ_BY_IDX(node_id, idx) is valid.
+ * If it returns 0, it is an error to use that macro with this index.
+ * @param node_id node identifier
+ * @param idx index to check
+ * @return 1 if the idx is valid for the interrupt property
+ *         0 otherwise.
+ */
+#define DT_IRQ_HAS_IDX(node_id, idx) \
+	IS_ENABLED(DT_CAT(node_id, _IRQ_IDX_##idx##_EXISTS))
+
+/**
+ * @brief Does an interrupts property have a named cell specifier at an index?
+ * If this returns 1, then DT_IRQ_BY_IDX(node_id, idx, cell) is valid.
+ * If it returns 0, it is an error to use that macro.
+ * @param node_id node identifier
+ * @param idx index to check
+ * @param cell named cell value whose existence to check
+ * @return 1 if the named cell exists in the interrupt specifier at index idx
+ *         0 otherwise.
+ */
+#define DT_IRQ_HAS_CELL_AT_IDX(node_id, idx, cell) \
+	IS_ENABLED(DT_CAT(node_id, _IRQ_IDX_##idx##_VAL_##cell##_EXISTS))
+
+/**
+ * @brief Equivalent to DT_IRQ_HAS_CELL_AT_IDX(node_id, 0, cell)
+ * @param node_id node identifier
+ * @param cell named cell value whose existence to check
+ * @return 1 if the named cell exists in the interrupt specifier at index 0
+ *         0 otherwise.
+ */
+#define DT_IRQ_HAS_CELL(node_id, cell) DT_IRQ_HAS_CELL_AT_IDX(node_id, 0, cell)
+
+/**
+ * @brief Does an interrupts property have a named specifier value at an index?
+ * If this returns 1, then DT_IRQ_BY_NAME(node_id, name, cell) is valid.
+ * If it returns 0, it is an error to use that macro.
+ * @param node_id node identifier
+ * @param name lowercase-and-underscores interrupt specifier name
+ * @return 1 if "name" is a valid named specifier
+ *         0 otherwise.
+ */
+#define DT_IRQ_HAS_NAME(node_id, name) \
+	IS_ENABLED(DT_CAT(node_id, _IRQ_NAME_##name##_VAL_irq_EXISTS))
+
+/**
+ * @brief Get a value within an interrupt specifier at an index
+ *
+ * It might help to read the argument order as being similar to
+ * "node->interrupts[index].cell".
+ *
+ * This can be used to get information about an individual interrupt
+ * when a device generates more than one.
+ *
+ * Example devicetree fragment:
+ *
+ *     my-serial: serial@... {
+ *             interrupts = < 33 0 >, < 34 1 >;
+ *     };
+ *
+ * Assuming the node's interrupt domain has "#interrupt-cells = <2>;" and
+ * the individual cells in each interrupt specifier are named "irq" and
+ * "priority" by the node's binding, here are some examples:
+ *
+ *     #define SERIAL DT_NODELABEL(my_serial)
+ *
+ *     Example usage                       Value
+ *     -------------                       -----
+ *     DT_IRQ_BY_IDX(SERIAL, 0, irq)          33
+ *     DT_IRQ_BY_IDX(SERIAL, 0, priority)      0
+ *     DT_IRQ_BY_IDX(SERIAL, 1, irq,          34
+ *     DT_IRQ_BY_IDX(SERIAL, 1, priority)      1
+ *
+ * @param node_id node identifier
+ * @param idx logical index into the interrupt specifier array
+ * @param cell cell name specifier
+ * @return the named value at the specifier given by the index
+ */
+#define DT_IRQ_BY_IDX(node_id, idx, cell)   \
+	DT_CAT(node_id, _IRQ_IDX_##idx##_VAL_##cell)
+
+/**
+ * @brief Get a value within an interrupt specifier by name
+ *
+ * It might help to read the argument order as being similar to
+ * "node->interrupts.name.cell".
+ *
+ * This can be used to get information about an individual interrupt
+ * when a device generates more than one, if the bindings give each
+ * interrupt specifier a name.
+ *
+ * @param node_id node identifier
+ * @param name lowercase-and-underscores interrupt specifier name
+ * @param cell cell name specifier
+ * @return the named value at the specifier given by the index
+ */
+#define DT_IRQ_BY_NAME(node_id, name, cell) \
+	DT_CAT(node_id, _IRQ_NAME_##name##_VAL_##cell)
+
+/**
+ * @brief Get an interrupt specifier's value
+ * Equivalent to DT_IRQ_BY_IDX(node_id, 0, cell).
+ * @param node_id node identifier
+ * @param cell cell name specifier
+ * @return the named value at that index
+ */
+#define DT_IRQ(node_id, cell) DT_IRQ_BY_IDX(node_id, 0, cell)
+
+/**
+ * @brief Get a node's (only) irq number
+ *
+ * Equivalent to DT_IRQ(node_id, irq). This is provided as a convenience
+ * for the common case where a node generates exactly one interrupt,
+ * and the IRQ number is in a cell named "irq".
+ *
+ * @param node_id node identifier
+ * @return the interrupt number for the node's only interrupt
+ */
+#define DT_IRQN(node_id) DT_IRQ(node_id, irq)
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup devicetree-generic-chosen Chosen nodes
+ * @ingroup devicetree
+ * @{
+ */
+
+/**
+ * @brief Get a node identifier for a /chosen node property
+ *
+ * This is only valid to call if DT_HAS_CHOSEN(prop) is 1.
+ * @param prop lowercase-and-underscores property name for
+ *             the /chosen node
+ * @return a node identifier for the chosen node property
+ */
+#define DT_CHOSEN(prop) DT_CAT(DT_CHOSEN_, prop)
+
+/**
+ * @brief Test if the devicetree has a /chosen node
+ * @param prop lowercase-and-underscores devicetree property
+ * @return 1 if the chosen property exists and refers to a node,
+ *         0 otherwise
+ */
+#define DT_HAS_CHOSEN(prop) IS_ENABLED(DT_CHOSEN_##prop##_EXISTS)
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup devicetree-generic-foreach "For-each" macros
+ * @ingroup devicetree
+ * @{
+ */
+
+/**
+ * @brief Invokes "fn" for each child of "node_id"
+ *
+ * The macro "fn" must take one parameter, which will be the node
+ * identifier of a child node of "node_id".
+ *
+ * Example devicetree fragment:
+ *
+ *     n: node {
+ *             child-1 {
+ *                     label = "foo";
+ *             };
+ *             child-2 {
+ *                     label = "bar";
+ *             };
+ *     };
+ *
+ * Example usage:
+ *
+ *     #define LABEL_AND_COMMA(node_id) DT_LABEL(node_id),
+ *
+ *     const char *child_labels[] = {
+ *         DT_FOREACH_CHILD(DT_NODELABEL(n), LABEL_AND_COMMA)
+ *     };
+ *
+ * This expands to:
+ *
+ *     const char *child_labels[] = {
+ *         "foo", "bar",
+ *     };
+ *
+ * @param node_id node identifier
+ * @param fn macro to invoke
+ */
+#define DT_FOREACH_CHILD(node_id, fn) \
+	DT_CAT(node_id, _FOREACH_CHILD)(fn)
+
+/**
+ * @brief Invokes "fn" for each child of "node_id" with multiple arguments
+ *
+ * The macro "fn" takes multiple arguments. The first should be the node
+ * identifier for the child node. The remaining are passed-in by the caller.
+ *
+ * @param node_id node identifier
+ * @param fn macro to invoke
+ * @param ... variable number of arguments to pass to fn
+ *
+ * @see DT_FOREACH_CHILD
+ */
+#define DT_FOREACH_CHILD_VARGS(node_id, fn, ...) \
+	DT_CAT(node_id, _FOREACH_CHILD_VARGS)(fn, __VA_ARGS__)
+
+/**
+ * @brief Call "fn" on the child nodes with status "okay"
+ *
+ * The macro "fn" should take one argument, which is the node
+ * identifier for the child node.
+ *
+ * As usual, both a missing status and an "ok" status are
+ * treated as "okay".
+ *
+ * @param node_id node identifier
+ * @param fn macro to invoke
+ */
+#define DT_FOREACH_CHILD_STATUS_OKAY(node_id, fn) \
+	DT_CAT(node_id, _FOREACH_CHILD_STATUS_OKAY)(fn)
+
+/**
+ * @brief Call "fn" on the child nodes with status "okay" with multiple
+ * arguments
+ *
+ * The macro "fn" takes multiple arguments. The first should be the node
+ * identifier for the child node. The remaining are passed-in by the caller.
+ *
+ * As usual, both a missing status and an "ok" status are
+ * treated as "okay".
+ *
+ * @param node_id node identifier
+ * @param fn macro to invoke
+ * @param ... variable number of arguments to pass to fn
+ *
+ * @see DT_FOREACH_CHILD_STATUS_OKAY
+ */
+#define DT_FOREACH_CHILD_STATUS_OKAY_VARGS(node_id, fn, ...) \
+	DT_CAT(node_id, _FOREACH_CHILD_STATUS_OKAY_VARGS)(fn, __VA_ARGS__)
+
+/**
+ * @brief Invokes "fn" for each element in the value of property "prop".
+ *
+ * The macro "fn" must take three parameters: fn(node_id, prop, idx).
+ * "node_id" and "prop" are the same as what is passed to
+ * DT_FOREACH_PROP_ELEM, and "idx" is the current index into the array.
+ * The "idx" values are integer literals starting from 0.
+ *
+ * Example devicetree fragment:
+ *
+ *     n: node {
+ *             my-ints = <1 2 3>;
+ *     };
+ *
+ * Example usage:
+ *
+ *     #define TIMES_TWO(node_id, prop, idx) \
+ *	       (2 * DT_PROP_BY_IDX(node_id, prop, idx)),
+ *
+ *     int array[] = {
+ *             DT_FOREACH_PROP_ELEM(DT_NODELABEL(n), my_ints, TIMES_TWO)
+ *     };
+ *
+ * This expands to:
+ *
+ *     int array[] = {
+ *             (2 * 1), (2 * 2), (2 * 3),
+ *     };
+ *
+ * In general, this macro expands to:
+ *
+ *     fn(node_id, prop, 0) fn(node_id, prop, 1) [...] fn(node_id, prop, n-1)
+ *
+ * where "n" is the number of elements in "prop", as it would be
+ * returned by <tt>DT_PROP_LEN(node_id, prop)</tt>.
+ *
+ * The "prop" argument must refer to a property with type string,
+ * array, uint8-array, string-array, phandles, or phandle-array. It is
+ * an error to use this macro with properties of other types.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property name
+ * @param fn macro to invoke
+ */
+#define DT_FOREACH_PROP_ELEM(node_id, prop, fn)		\
+	DT_CAT4(node_id, _P_, prop, _FOREACH_PROP_ELEM)(fn)
+
+/**
+ * @brief Invokes "fn" for each element in the value of property "prop" with
+ * multiple arguments.
+ *
+ * The macro "fn" must take multiple parameters: fn(node_id, prop, idx, ...).
+ * "node_id" and "prop" are the same as what is passed to
+ * DT_FOREACH_PROP_ELEM, and "idx" is the current index into the array.
+ * The "idx" values are integer literals starting from 0. The remaining
+ * arguments are passed-in by the caller.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property name
+ * @param fn macro to invoke
+ * @param ... variable number of arguments to pass to fn
+ *
+ * @see DT_FOREACH_PROP_ELEM
+ */
+#define DT_FOREACH_PROP_ELEM_VARGS(node_id, prop, fn, ...)		\
+	DT_CAT4(node_id, _P_, prop, _FOREACH_PROP_ELEM_VARGS)(fn, __VA_ARGS__)
+
+/**
+ * @brief Call "fn" on all nodes with compatible DT_DRV_COMPAT
+ *        and status "okay"
+ *
+ * This macro expands to:
+ *
+ *     fn(node_id_1) fn(node_id_2) ... fn(node_id_n)
+ *
+ * where each "node_id_<i>" is a node identifier for some node with
+ * compatible "compat" and status "okay". Whitespace is added between
+ * expansions as shown above.
+ *
+ * Example devicetree fragment:
+ *
+ *     / {
+ *             a {
+ *                     compatible = "foo";
+ *                     status = "okay";
+ *             };
+ *             b {
+ *                     compatible = "foo";
+ *                     status = "disabled";
+ *             };
+ *             c {
+ *                     compatible = "foo";
+ *             };
+ *     };
+ *
+ * Example usage:
+ *
+ *     DT_FOREACH_STATUS_OKAY(foo, DT_NODE_PATH)
+ *
+ * This expands to one of the following:
+ *
+ *     "/a" "/c"
+ *     "/c" "/a"
+ *
+ * "One of the following" is because no guarantees are made about the
+ * order that node identifiers are passed to "fn" in the expansion.
+ *
+ * (The "/c" string literal is present because a missing status
+ * property is always treated as if the status were set to "okay".)
+ *
+ * Note also that "fn" is responsible for adding commas, semicolons,
+ * or other terminators as needed.
+ *
+ * @param compat lowercase-and-underscores devicetree compatible
+ * @param fn Macro to call for each enabled node. Must accept a
+ *           node_id as its only parameter.
+ */
+#define DT_FOREACH_STATUS_OKAY(compat, fn)				\
+	COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(compat),			\
+		    (UTIL_CAT(DT_FOREACH_OKAY_, compat)(fn)),	\
+		    ())
+
+/**
+ * @brief Invokes "fn" for each status "okay" node of a compatible
+ *        with multiple arguments.
+ *
+ * This is like DT_FOREACH_STATUS_OKAY() except you can also pass
+ * additional arguments to "fn".
+ *
+ * Example devicetree fragment:
+ *
+ *     / {
+ *             a {
+ *                     compatible = "foo";
+ *                     val = <3>;
+ *             };
+ *             b {
+ *                     compatible = "foo";
+ *                     val = <4>;
+ *             };
+ *     };
+ *
+ * Example usage:
+ *
+ *     #define MY_FN(node_id, operator) DT_PROP(node_id, val) operator
+ *     x = DT_FOREACH_STATUS_OKAY_VARGS(foo, MY_FN, +) 0;
+ *
+ * This expands to one of the following:
+ *
+ *     x = 3 + 4 + 0;
+ *     x = 4 + 3 + 0;
+ *
+ * i.e. it sets x to 7. As with DT_FOREACH_STATUS_OKAY(), there are no
+ * guarantees about the order nodes appear in the expansion.
+ *
+ * @param compat lowercase-and-underscores devicetree compatible
+ * @param fn Macro to call for each enabled node. Must accept a
+ *           node_id as its only parameter.
+ * @param ... Additional arguments to pass to "fn"
+ */
+#define DT_FOREACH_STATUS_OKAY_VARGS(compat, fn, ...)			\
+	COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(compat),			\
+		    (UTIL_CAT(DT_FOREACH_OKAY_VARGS_,			\
+			      compat)(fn, __VA_ARGS__)),		\
+		    ())
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup devicetree-generic-exist Existence checks
+ * @ingroup devicetree
+ * @{
+ */
+
+/**
+ * @brief Does a node identifier refer to a node?
+ *
+ * Tests whether a node identifier refers to a node which exists, i.e.
+ * is defined in the devicetree.
+ *
+ * It doesn't matter whether or not the node has a matching binding,
+ * or what the node's status value is. This is purely a check of
+ * whether the node exists at all.
+ *
+ * @param node_id a node identifier
+ * @return 1 if the node identifier refers to a node,
+ *         0 otherwise.
+ */
+#define DT_NODE_EXISTS(node_id) IS_ENABLED(DT_CAT(node_id, _EXISTS))
+
+/**
+ * @brief Does a node identifier refer to a node with a status?
+ *
+ * Example uses:
+ *
+ *     DT_NODE_HAS_STATUS(DT_PATH(soc, i2c_12340000), okay)
+ *     DT_NODE_HAS_STATUS(DT_PATH(soc, i2c_12340000), disabled)
+ *
+ * Tests whether a node identifier refers to a node which:
+ *
+ * - exists in the devicetree, and
+ * - has a status property matching the second argument
+ *   (except that either a missing status or an "ok" status
+ *   in the devicetree is treated as if it were "okay" instead)
+ *
+ * @param node_id a node identifier
+ * @param status a status as one of the tokens okay or disabled, not a string
+ * @return 1 if the node has the given status, 0 otherwise.
+ */
+#define DT_NODE_HAS_STATUS(node_id, status) \
+	DT_NODE_HAS_STATUS_INTERNAL(node_id, status)
+
+/**
+ * @brief Does the devicetree have a status "okay" node with a compatible?
+ *
+ * Test for whether the devicetree has any nodes with status "okay"
+ * and the given compatible. That is, this returns 1 if and only if
+ * there is at least one "node_id" for which both of these
+ * expressions return 1:
+ *
+ *     DT_NODE_HAS_STATUS(node_id, okay)
+ *     DT_NODE_HAS_COMPAT(node_id, compat)
+ *
+ * As usual, both a missing status and an "ok" status are treated as
+ * "okay".
+ *
+ * @param compat lowercase-and-underscores compatible, without quotes
+ * @return 1 if both of the above conditions are met, 0 otherwise
+ */
+#define DT_HAS_COMPAT_STATUS_OKAY(compat) \
+	IS_ENABLED(DT_CAT(DT_COMPAT_HAS_OKAY_, compat))
+
+/**
+ * @brief Get the number of instances of a given compatible with
+ *        status "okay"
+ * @param compat lowercase-and-underscores compatible, without quotes
+ * @return Number of instances with status "okay"
+ */
+#define DT_NUM_INST_STATUS_OKAY(compat)			\
+	UTIL_AND(DT_HAS_COMPAT_STATUS_OKAY(compat),		\
+		 UTIL_CAT(DT_N_INST, DT_DASH(compat, NUM_OKAY)))
+
+/**
+ * @brief Does a devicetree node match a compatible?
+ *
+ * Example devicetree fragment:
+ *
+ *     n: node {
+ *             compatible = "vnd,specific-device", "generic-device";
+ *     }
+ *
+ * Example usages which evaluate to 1:
+ *
+ *     DT_NODE_HAS_COMPAT(DT_NODELABEL(n), vnd_specific_device)
+ *     DT_NODE_HAS_COMPAT(DT_NODELABEL(n), generic_device)
+ *
+ * This macro only uses the value of the compatible property. Whether
+ * or not a particular compatible has a matching binding has no effect
+ * on its value, nor does the node's status.
+ *
+ * @param node_id node identifier
+ * @param compat lowercase-and-underscores compatible, without quotes
+ * @return 1 if the node's compatible property contains compat,
+ *         0 otherwise.
+ */
+#define DT_NODE_HAS_COMPAT(node_id, compat) \
+	IS_ENABLED(DT_CAT(node_id, _COMPAT_MATCHES_##compat))
+
+/**
+ * @brief Does a devicetree node have a compatible and status?
+ *
+ * This is equivalent to:
+ *
+ *     (DT_NODE_HAS_COMPAT(node_id, compat) &&
+ *      DT_NODE_HAS_STATUS(node_id, status))
+ *
+ * @param node_id node identifier
+ * @param compat lowercase-and-underscores compatible, without quotes
+ * @param status okay or disabled as a token, not a string
+ */
+#define DT_NODE_HAS_COMPAT_STATUS(node_id, compat, status) \
+	DT_NODE_HAS_COMPAT(node_id, compat) && DT_NODE_HAS_STATUS(node_id, status)
+
+/**
+ * @brief Does a devicetree node have a property?
+ *
+ * Tests whether a devicetree node has a property defined.
+ *
+ * This tests whether the property is defined at all, not whether a
+ * boolean property is true or false. To get a boolean property's
+ * truth value, use DT_PROP(node_id, prop) instead.
+ *
+ * @param node_id node identifier
+ * @param prop lowercase-and-underscores property name
+ * @return 1 if the node has the property, 0 otherwise.
+ */
+#define DT_NODE_HAS_PROP(node_id, prop) \
+	IS_ENABLED(DT_CAT(node_id, _P_##prop##_EXISTS))
+
+
+/**
+ * @brief Does a phandle array have a named cell specifier at an index?
+ *
+ * If this returns 1, then the phandle-array property "pha" has a cell
+ * named "cell" at index "idx", and therefore DT_PHA_BY_IDX(node_id,
+ * pha, idx, cell) is valid. If it returns 0, it's an error to use
+ * DT_PHA_BY_IDX() with the same arguments.
+ *
+ * @param node_id node identifier
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param idx index to check within "pha"
+ * @param cell lowercase-and-underscores cell name whose existence to check
+ *             at index "idx"
+ * @return 1 if the named cell exists in the specifier at index idx,
+ *         0 otherwise.
+ */
+#define DT_PHA_HAS_CELL_AT_IDX(node_id, pha, idx, cell)             \
+	IS_ENABLED(DT_PROP(node_id,                                 \
+			   pha##_IDX_##idx##_VAL_##cell##_EXISTS))
+
+/**
+ * @brief Equivalent to DT_PHA_HAS_CELL_AT_IDX(node_id, pha, 0, cell)
+ * @param node_id node identifier
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param cell lowercase-and-underscores cell name whose existence to check
+ *             at index "idx"
+ * @return 1 if the named cell exists in the specifier at index 0,
+ *         0 otherwise.
+ */
+#define DT_PHA_HAS_CELL(node_id, pha, cell) \
+	DT_PHA_HAS_CELL_AT_IDX(node_id, pha, 0, cell)
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup devicetree-generic-bus Bus helpers
+ * @ingroup devicetree
+ * @{
+ */
+
+/**
+ * @brief Node's bus controller
+ *
+ * Get the node identifier of the node's bus controller. This can be
+ * used with @ref DT_PROP() to get properties of the bus controller.
+ *
+ * It is an error to use this with nodes which do not have bus
+ * controllers.
+ *
+ * Example devicetree fragment:
+ *
+ *     i2c@deadbeef {
+ *             label = "I2C_CTLR";
+ *             status = "okay";
+ *             clock-frequency = < 100000 >;
+ *
+ *             i2c_device: accelerometer@12 {
+ *                     ...
+ *             };
+ *     };
+ *
+ * Example usage:
+ *
+ *     DT_PROP(DT_BUS(DT_NODELABEL(i2c_device)), clock_frequency) // 100000
+ *
+ * @param node_id node identifier
+ * @return a node identifier for the node's bus controller
+ */
+#define DT_BUS(node_id) DT_CAT(node_id, _BUS)
+
+/**
+ * @brief Node's bus controller's label property
+ * @param node_id node identifier
+ * @return the label property of the node's bus controller DT_BUS(node)
+ */
+#define DT_BUS_LABEL(node_id) DT_PROP(DT_BUS(node_id), label)
+
+/**
+ * @brief Is a node on a bus of a given type?
+ *
+ * Example devicetree overlay:
+ *
+ *     &i2c0 {
+ *            temp: temperature-sensor@76 {
+ *                     compatible = "vnd,some-sensor";
+ *                     reg = <0x76>;
+ *            };
+ *     };
+ *
+ * Example usage, assuming "i2c0" is an I2C bus controller node, and
+ * therefore "temp" is on an I2C bus:
+ *
+ *     DT_ON_BUS(DT_NODELABEL(temp), i2c) // 1
+ *     DT_ON_BUS(DT_NODELABEL(temp), spi) // 0
+ *
+ * @param node_id node identifier
+ * @param bus lowercase-and-underscores bus type as a C token (i.e.
+ *            without quotes)
+ * @return 1 if the node is on a bus of the given type,
+ *         0 otherwise
+ */
+#define DT_ON_BUS(node_id, bus) IS_ENABLED(DT_CAT(node_id, _BUS_##bus))
+
+/**
+ * @}
+ */
+
+/**
+ * @defgroup devicetree-inst Instance-based devicetree APIs
+ * @ingroup devicetree
+ * @{
+ */
+
+/**
+ * @brief Node identifier for an instance of a DT_DRV_COMPAT compatible
+ * @param inst instance number
+ * @return a node identifier for the node with DT_DRV_COMPAT compatible and
+ *         instance number "inst"
+ */
+#define DT_DRV_INST(inst) DT_INST(inst, DT_DRV_COMPAT)
+
+/**
+ * @brief Call "fn" on all child nodes of DT_DRV_INST(inst).
+ *
+ * The macro "fn" should take one argument, which is the node
+ * identifier for the child node.
+ *
+ * @param inst instance number
+ * @param fn macro to invoke on each child node identifier
+ *
+ * @see DT_FOREACH_CHILD
+ */
+#define DT_INST_FOREACH_CHILD(inst, fn) \
+	DT_FOREACH_CHILD(DT_DRV_INST(inst), fn)
+
+/**
+ * @brief Call "fn" on all child nodes of DT_DRV_INST(inst).
+ *
+ * The macro "fn" takes multiple arguments. The first should be the node
+ * identifier for the child node. The remaining are passed-in by the caller.
+ *
+ * @param inst instance number
+ * @param fn macro to invoke on each child node identifier
+ * @param ... variable number of arguments to pass to fn
+ *
+ * @see DT_FOREACH_CHILD
+ */
+#define DT_INST_FOREACH_CHILD_VARGS(inst, fn, ...) \
+	DT_FOREACH_CHILD_VARGS(DT_DRV_INST(inst), fn, __VA_ARGS__)
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance property
+ * @param inst instance number
+ * @param prop lowercase-and-underscores property name
+ * @return a representation of the property's value
+ */
+#define DT_INST_PROP(inst, prop) DT_PROP(DT_DRV_INST(inst), prop)
+
+/**
+ * @brief Get a DT_DRV_COMPAT property length
+ * @param inst instance number
+ * @param prop lowercase-and-underscores property name
+ * @return logical length of the property
+ */
+#define DT_INST_PROP_LEN(inst, prop) DT_PROP_LEN(DT_DRV_INST(inst), prop)
+
+/**
+ * @brief Is index "idx" valid for an array type property
+ *        on a DT_DRV_COMPAT instance?
+ * @param inst instance number
+ * @param prop lowercase-and-underscores property name
+ * @param idx index to check
+ * @return 1 if "idx" is a valid index into the given property,
+ *         0 otherwise.
+ */
+#define DT_INST_PROP_HAS_IDX(inst, prop, idx) \
+	DT_PROP_HAS_IDX(DT_DRV_INST(inst), prop, idx)
+
+/**
+ * @brief Get a DT_DRV_COMPAT element value in an array property
+ * @param inst instance number
+ * @param prop lowercase-and-underscores property name
+ * @param idx the index to get
+ * @return a representation of the idx-th element of the property
+ */
+#define DT_INST_PROP_BY_IDX(inst, prop, idx) \
+	DT_PROP_BY_IDX(DT_DRV_INST(inst), prop, idx)
+
+/**
+ * @brief Like DT_INST_PROP(), but with a fallback to default_value
+ * @param inst instance number
+ * @param prop lowercase-and-underscores property name
+ * @param default_value a fallback value to expand to
+ * @return DT_INST_PROP(inst, prop) or default_value
+ */
+#define DT_INST_PROP_OR(inst, prop, default_value) \
+	DT_PROP_OR(DT_DRV_INST(inst), prop, default_value)
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance's "label" property
+ * @param inst instance number
+ * @return instance's label property value
+ */
+#define DT_INST_LABEL(inst) DT_INST_PROP(inst, label)
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance's property value from a phandle's node
+ * @param inst instance number
+ * @param ph lowercase-and-underscores property of "inst"
+ *           with type "phandle"
+ * @param prop lowercase-and-underscores property of the phandle's node
+ * @return the value of "prop" as described in the DT_PROP() documentation
+ */
+#define DT_INST_PROP_BY_PHANDLE(inst, ph, prop) \
+	DT_INST_PROP_BY_PHANDLE_IDX(inst, ph, 0, prop)
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance's property value from a phandle in a
+ * property.
+ * @param inst instance number
+ * @param phs lowercase-and-underscores property with type "phandle",
+ *            "phandles", or "phandle-array"
+ * @param idx logical index into "phs", which must be zero if "phs"
+ *            has type "phandle"
+ * @param prop lowercase-and-underscores property of the phandle's node
+ * @return the value of "prop" as described in the DT_PROP() documentation
+ */
+#define DT_INST_PROP_BY_PHANDLE_IDX(inst, phs, idx, prop) \
+	DT_PROP_BY_PHANDLE_IDX(DT_DRV_INST(inst), phs, idx, prop)
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance's phandle-array specifier value at an index
+ * @param inst instance number
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param idx logical index into the property "pha"
+ * @param cell binding's cell name within the specifier at index "idx"
+ * @return the value of the cell inside the specifier at index "idx"
+ */
+#define DT_INST_PHA_BY_IDX(inst, pha, idx, cell) \
+	DT_PHA_BY_IDX(DT_DRV_INST(inst), pha, idx, cell)
+
+/**
+ * @brief Like DT_INST_PHA_BY_IDX(), but with a fallback to default_value
+ * @param inst instance number
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param idx logical index into the property "pha"
+ * @param cell binding's cell name within the specifier at index "idx"
+ * @param default_value a fallback value to expand to
+ * @return DT_INST_PHA_BY_IDX(inst, pha, idx, cell) or default_value
+ */
+#define DT_INST_PHA_BY_IDX_OR(inst, pha, idx, cell, default_value) \
+	DT_PHA_BY_IDX_OR(DT_DRV_INST(inst), pha, idx, cell, default_value)
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance's phandle-array specifier value
+ * Equivalent to DT_INST_PHA_BY_IDX(inst, pha, 0, cell)
+ * @param inst instance number
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param cell binding's cell name for the specifier at "pha" index 0
+ * @return the cell value
+ */
+#define DT_INST_PHA(inst, pha, cell) DT_INST_PHA_BY_IDX(inst, pha, 0, cell)
+
+/**
+ * @brief Like DT_INST_PHA(), but with a fallback to default_value
+ * @param inst instance number
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param cell binding's cell name for the specifier at "pha" index 0
+ * @param default_value a fallback value to expand to
+ * @return DT_INST_PHA(inst, pha, cell) or default_value
+ */
+#define DT_INST_PHA_OR(inst, pha, cell, default_value) \
+	DT_INST_PHA_BY_IDX_OR(inst, pha, 0, cell, default_value)
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance's value within a phandle-array
+ * specifier by name
+ * @param inst instance number
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param name lowercase-and-underscores name of a specifier in "pha"
+ * @param cell binding's cell name for the named specifier
+ * @return the cell value
+ */
+#define DT_INST_PHA_BY_NAME(inst, pha, name, cell) \
+	DT_PHA_BY_NAME(DT_DRV_INST(inst), pha, name, cell)
+
+/**
+ * @brief Like DT_INST_PHA_BY_NAME(), but with a fallback to default_value
+ * @param inst instance number
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param name lowercase-and-underscores name of a specifier in "pha"
+ * @param cell binding's cell name for the named specifier
+ * @param default_value a fallback value to expand to
+ * @return DT_INST_PHA_BY_NAME(inst, pha, name, cell) or default_value
+ */
+#define DT_INST_PHA_BY_NAME_OR(inst, pha, name, cell, default_value) \
+	DT_PHA_BY_NAME_OR(DT_DRV_INST(inst), pha, name, cell, default_value)
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance's phandle node identifier from a
+ * phandle array by name
+ * @param inst instance number
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param name lowercase-and-underscores name of an element in "pha"
+ * @return node identifier for the phandle at the element named "name"
+ */
+#define DT_INST_PHANDLE_BY_NAME(inst, pha, name) \
+	DT_PHANDLE_BY_NAME(DT_DRV_INST(inst), pha, name) \
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance's node identifier for a phandle in
+ * a property.
+ * @param inst instance number
+ * @param prop lowercase-and-underscores property name in "inst"
+ *             with type "phandle", "phandles" or "phandle-array"
+ * @param idx index into "prop"
+ * @return a node identifier for the phandle at index "idx" in "prop"
+ */
+#define DT_INST_PHANDLE_BY_IDX(inst, prop, idx) \
+	DT_PHANDLE_BY_IDX(DT_DRV_INST(inst), prop, idx)
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance's node identifier for a phandle
+ * property's value
+ * @param inst instance number
+ * @param prop lowercase-and-underscores property of "inst"
+ *             with type "phandle"
+ * @return a node identifier for the node pointed to by "ph"
+ */
+#define DT_INST_PHANDLE(inst, prop) DT_INST_PHANDLE_BY_IDX(inst, prop, 0)
+
+/**
+ * @brief is "idx" a valid register block index on a DT_DRV_COMPAT instance?
+ * @param inst instance number
+ * @param idx index to check
+ * @return 1 if "idx" is a valid register block index,
+ *         0 otherwise.
+ */
+#define DT_INST_REG_HAS_IDX(inst, idx) DT_REG_HAS_IDX(DT_DRV_INST(inst), idx)
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance's idx-th register block's address
+ * @param inst instance number
+ * @param idx index of the register whose address to return
+ * @return address of the instance's idx-th register block
+ */
+#define DT_INST_REG_ADDR_BY_IDX(inst, idx) DT_REG_ADDR_BY_IDX(DT_DRV_INST(inst), idx)
+
+/**
+ * @brief Get a DT_DRV_COMPAT instance's idx-th register block's size
+ * @param inst instance number
+ * @param idx index of the register whose size to return
+ * @return size of the instance's idx-th register block
+ */
+#define DT_INST_REG_SIZE_BY_IDX(inst, idx) \
+	DT_REG_SIZE_BY_IDX(DT_DRV_INST(inst), idx)
+
+/**
+ * @brief Get a DT_DRV_COMPAT's register block address by name
+ * @param inst instance number
+ * @param name lowercase-and-underscores register specifier name
+ * @return address of the register block with the given name
+ */
+#define DT_INST_REG_ADDR_BY_NAME(inst, name) \
+	DT_REG_ADDR_BY_NAME(DT_DRV_INST(inst), name)
+
+/**
+ * @brief Get a DT_DRV_COMPAT's register block size by name
+ * @param inst instance number
+ * @param name lowercase-and-underscores register specifier name
+ * @return size of the register block with the given name
+ */
+#define DT_INST_REG_SIZE_BY_NAME(inst, name) \
+	DT_REG_SIZE_BY_NAME(DT_DRV_INST(inst), name)
+
+/**
+ * @brief Get a DT_DRV_COMPAT's (only) register block address
+ * @param inst instance number
+ * @return instance's register block address
+ */
+#define DT_INST_REG_ADDR(inst) DT_INST_REG_ADDR_BY_IDX(inst, 0)
+
+/**
+ * @brief Get a DT_DRV_COMPAT's (only) register block size
+ * @param inst instance number
+ * @return instance's register block size
+ */
+#define DT_INST_REG_SIZE(inst) DT_INST_REG_SIZE_BY_IDX(inst, 0)
+
+/**
+ * @brief Get a DT_DRV_COMPAT interrupt specifier value at an index
+ * @param inst instance number
+ * @param idx logical index into the interrupt specifier array
+ * @param cell cell name specifier
+ * @return the named value at the specifier given by the index
+ */
+#define DT_INST_IRQ_BY_IDX(inst, idx, cell) \
+	DT_IRQ_BY_IDX(DT_DRV_INST(inst), idx, cell)
+
+/**
+ * @brief Get a DT_DRV_COMPAT interrupt specifier value by name
+ * @param inst instance number
+ * @param name lowercase-and-underscores interrupt specifier name
+ * @param cell cell name specifier
+ * @return the named value at the specifier given by the index
+ */
+#define DT_INST_IRQ_BY_NAME(inst, name, cell) \
+	DT_IRQ_BY_NAME(DT_DRV_INST(inst), name, cell)
+
+/**
+ * @brief Get a DT_DRV_COMPAT interrupt specifier's value
+ * @param inst instance number
+ * @param cell cell name specifier
+ * @return the named value at that index
+ */
+#define DT_INST_IRQ(inst, cell) DT_INST_IRQ_BY_IDX(inst, 0, cell)
+
+/**
+ * @brief Get a DT_DRV_COMPAT's (only) irq number
+ * @param inst instance number
+ * @return the interrupt number for the node's only interrupt
+ */
+#define DT_INST_IRQN(inst) DT_INST_IRQ(inst, irq)
+
+/**
+ * @brief Get a DT_DRV_COMPAT's bus node identifier
+ * @param inst instance number
+ * @return node identifier for the instance's bus node
+ */
+#define DT_INST_BUS(inst) DT_BUS(DT_DRV_INST(inst))
+
+/**
+ * @brief Get a DT_DRV_COMPAT's bus node's label property
+ * @param inst instance number
+ * @return the label property of the instance's bus controller
+ */
+#define DT_INST_BUS_LABEL(inst) DT_BUS_LABEL(DT_DRV_INST(inst))
+
+/**
+ * @brief Test if a DT_DRV_COMPAT's bus type is a given type
+ * @param inst instance number
+ * @param bus a binding's bus type as a C token, lowercased and without quotes
+ * @return 1 if the given instance is on a bus of the given type,
+ *         0 otherwise
+ */
+#define DT_INST_ON_BUS(inst, bus) DT_ON_BUS(DT_DRV_INST(inst), bus)
+
+/**
+ * @brief Test if any DT_DRV_COMPAT node is on a bus of a given type
+ *        and has status okay
+ *
+ * This is a special-purpose macro which can be useful when writing
+ * drivers for devices which can appear on multiple buses. One example
+ * is a sensor device which may be wired on an I2C or SPI bus.
+ *
+ * Example devicetree overlay:
+ *
+ *     &i2c0 {
+ *            temp: temperature-sensor@76 {
+ *                     compatible = "vnd,some-sensor";
+ *                     reg = <0x76>;
+ *            };
+ *     };
+ *
+ * Example usage, assuming "i2c0" is an I2C bus controller node, and
+ * therefore "temp" is on an I2C bus:
+ *
+ *     #define DT_DRV_COMPAT vnd_some_sensor
+ *
+ *     DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c) // 1
+ *
+ * @param bus a binding's bus type as a C token, lowercased and without quotes
+ * @return 1 if any enabled node with that compatible is on that bus type,
+ *         0 otherwise
+ */
+#define DT_ANY_INST_ON_BUS_STATUS_OKAY(bus) \
+	DT_COMPAT_ON_BUS_INTERNAL(DT_DRV_COMPAT, bus)
+
+/**
+ * @brief Call "fn" on all nodes with compatible DT_DRV_COMPAT
+ *        and status "okay"
+ *
+ * This macro calls "fn(inst)" on each "inst" number that refers to a
+ * node with status "okay". Whitespace is added between invocations.
+ *
+ * Example devicetree fragment:
+ *
+ *     a {
+ *             compatible = "vnd,device";
+ *             status = "okay";
+ *             label = "DEV_A";
+ *     };
+ *
+ *     b {
+ *             compatible = "vnd,device";
+ *             status = "okay";
+ *             label = "DEV_B";
+ *     };
+ *
+ *     c {
+ *             compatible = "vnd,device";
+ *             status = "disabled";
+ *             label = "DEV_C";
+ *     };
+ *
+ * Example usage:
+ *
+ *     #define DT_DRV_COMPAT vnd_device
+ *     #define MY_FN(inst) DT_INST_LABEL(inst),
+ *
+ *     DT_INST_FOREACH_STATUS_OKAY(MY_FN)
+ *
+ * This expands to:
+ *
+ *     MY_FN(0) MY_FN(1)
+ *
+ * and from there, to either this:
+ *
+ *     "DEV_A", "DEV_B",
+ *
+ * or this:
+ *
+ *     "DEV_B", "DEV_A",
+ *
+ * No guarantees are made about the order that a and b appear in the
+ * expansion.
+ *
+ * Note that "fn" is responsible for adding commas, semicolons, or
+ * other separators or terminators.
+ *
+ * Device drivers should use this macro whenever possible to
+ * instantiate a struct device for each enabled node in the devicetree
+ * of the driver's compatible DT_DRV_COMPAT.
+ *
+ * @param fn Macro to call for each enabled node. Must accept an
+ *           instance number as its only parameter.
+ */
+#define DT_INST_FOREACH_STATUS_OKAY(fn) \
+	COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT),	\
+		    (UTIL_CAT(DT_FOREACH_OKAY_INST_,		\
+			      DT_DRV_COMPAT)(fn)),		\
+		    ())
+
+/**
+ * @brief Call "fn" on all nodes with compatible DT_DRV_COMPAT
+ *        and status "okay" with multiple arguments
+ *
+ *
+ * @param fn Macro to call for each enabled node. Must accept an
+ *           instance number as its only parameter.
+ * @param ... variable number of arguments to pass to fn
+ *
+ * @see DT_INST_FOREACH_STATUS_OKAY
+ */
+#define DT_INST_FOREACH_STATUS_OKAY_VARGS(fn, ...) \
+	COND_CODE_1(DT_HAS_COMPAT_STATUS_OKAY(DT_DRV_COMPAT),	\
+		    (UTIL_CAT(DT_FOREACH_OKAY_INST_VARGS_,	\
+			      DT_DRV_COMPAT)(fn, __VA_ARGS__)),	\
+		    ())
+
+/**
+ * @brief Invokes "fn" for each element of property "prop" for
+ *        a DT_DRV_COMPAT instance.
+ *
+ * Equivalent to DT_FOREACH_PROP_ELEM(DT_DRV_INST(inst), prop, fn).
+ *
+ * @param inst instance number
+ * @param prop lowercase-and-underscores property name
+ * @param fn macro to invoke
+ */
+#define DT_INST_FOREACH_PROP_ELEM(inst, prop, fn) \
+	DT_FOREACH_PROP_ELEM(DT_DRV_INST(inst), prop, fn)
+
+/**
+ * @brief Invokes "fn" for each element of property "prop" for
+ *        a DT_DRV_COMPAT instance with multiple arguments.
+ *
+ * Equivalent to
+ *      DT_FOREACH_PROP_ELEM_VARGS(DT_DRV_INST(inst), prop, fn, __VA_ARGS__)
+ *
+ * @param inst instance number
+ * @param prop lowercase-and-underscores property name
+ * @param fn macro to invoke
+ * @param ... variable number of arguments to pass to fn
+ *
+ * @see DT_INST_FOREACH_PROP_ELEM
+ */
+#define DT_INST_FOREACH_PROP_ELEM_VARGS(inst, prop, fn, ...) \
+	DT_FOREACH_PROP_ELEM_VARGS(DT_DRV_INST(inst), prop, fn, __VA_ARGS__)
+
+/**
+ * @brief Does a DT_DRV_COMPAT instance have a property?
+ * @param inst instance number
+ * @param prop lowercase-and-underscores property name
+ * @return 1 if the instance has the property, 0 otherwise.
+ */
+#define DT_INST_NODE_HAS_PROP(inst, prop) \
+	DT_NODE_HAS_PROP(DT_DRV_INST(inst), prop)
+
+/**
+ * @brief Does a phandle array have a named cell specifier at an index
+ *        for a DT_DRV_COMPAT instance?
+ * @param inst instance number
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param idx index to check
+ * @param cell named cell value whose existence to check
+ * @return 1 if the named cell exists in the specifier at index idx,
+ *         0 otherwise.
+ */
+#define DT_INST_PHA_HAS_CELL_AT_IDX(inst, pha, idx, cell) \
+	DT_PHA_HAS_CELL_AT_IDX(DT_DRV_INST(inst), pha, idx, cell)
+
+/**
+ * @brief Does a phandle array have a named cell specifier at index 0
+ *        for a DT_DRV_COMPAT instance?
+ * @param inst instance number
+ * @param pha lowercase-and-underscores property with type "phandle-array"
+ * @param cell named cell value whose existence to check
+ * @return 1 if the named cell exists in the specifier at index 0,
+ *         0 otherwise.
+ */
+#define DT_INST_PHA_HAS_CELL(inst, pha, cell) \
+	DT_INST_PHA_HAS_CELL_AT_IDX(inst, pha, 0, cell)
+
+/**
+ * @brief is index valid for interrupt property on a DT_DRV_COMPAT instance?
+ * @param inst instance number
+ * @param idx logical index into the interrupt specifier array
+ * @return 1 if the idx is valid for the interrupt property
+ *         0 otherwise.
+ */
+#define DT_INST_IRQ_HAS_IDX(inst, idx) DT_IRQ_HAS_IDX(DT_DRV_INST(inst), idx)
+
+/**
+ * @brief Does a DT_DRV_COMPAT instance have an interrupt named cell specifier?
+ * @param inst instance number
+ * @param idx index to check
+ * @param cell named cell value whose existence to check
+ * @return 1 if the named cell exists in the interrupt specifier at index idx
+ *         0 otherwise.
+ */
+#define DT_INST_IRQ_HAS_CELL_AT_IDX(inst, idx, cell) \
+	DT_IRQ_HAS_CELL_AT_IDX(DT_DRV_INST(inst), idx, cell)
+
+/**
+ * @brief Does a DT_DRV_COMPAT instance have an interrupt value?
+ * @param inst instance number
+ * @param cell named cell value whose existence to check
+ * @return 1 if the named cell exists in the interrupt specifier at index 0
+ *         0 otherwise.
+ */
+#define DT_INST_IRQ_HAS_CELL(inst, cell) \
+	DT_INST_IRQ_HAS_CELL_AT_IDX(inst, 0, cell)
+
+/**
+ * @brief Does a DT_DRV_COMPAT instance have an interrupt value?
+ * @param inst instance number
+ * @param name lowercase-and-underscores interrupt specifier name
+ * @return 1 if "name" is a valid named specifier
+ */
+#define DT_INST_IRQ_HAS_NAME(inst, name) \
+	DT_IRQ_HAS_NAME(DT_DRV_INST(inst), name)
+
+/**
+ * @}
+ */
+
+/** @internal pay no attention to the man behind the curtain! */
+#define DT_PATH_INTERNAL(...) \
+	UTIL_CAT(DT_ROOT, MACRO_MAP_CAT(DT_S_PREFIX, __VA_ARGS__))
+/** @internal helper for DT_PATH(): prepends _S_ to a node name */
+#define DT_S_PREFIX(name) _S_##name
+
+/**
+ * @internal concatenation helper, 2 arguments
+ *
+ * This and the following macros are used to paste things together
+ * with "##" *after* forcing expansion on each argument.
+ *
+ * We could try to use something like UTIL_CAT(), but the compiler
+ * error messages from the util macros can be extremely long when they
+ * are misused. This unfortunately happens often with devicetree.h,
+ * since its macro-based API is fiddly and can be hard to get right.
+ *
+ * Keeping things brutally simple here hopefully makes some errors
+ * easier to read.
+ */
+#define DT_CAT(a1, a2) a1 ## a2
+/** @internal concatenation helper, 3 arguments */
+#define DT_CAT3(a1, a2, a3) a1 ## a2 ## a3
+/** @internal concatenation helper, 4 arguments */
+#define DT_CAT4(a1, a2, a3, a4) a1 ## a2 ## a3 ## a4
+/** @internal concatenation helper, 5 arguments */
+#define DT_CAT5(a1, a2, a3, a4, a5) a1 ## a2 ## a3 ## a4 ## a5
+/** @internal concatenation helper, 6 arguments */
+#define DT_CAT6(a1, a2, a3, a4, a5, a6) a1 ## a2 ## a3 ## a4 ## a5 ## a6
+/*
+ * If you need to define a bigger DT_CATN(), do so here. Don't leave
+ * any "holes" of undefined macros, please.
+ */
+
+/** @internal helper for node identifier macros to expand args */
+#define DT_DASH(...) MACRO_MAP_CAT(DT_DASH_PREFIX, __VA_ARGS__)
+/** @internal helper for DT_DASH(): prepends _ to a name */
+#define DT_DASH_PREFIX(name) _##name
+/** @internal helper for DT_NODE_HAS_STATUS */
+#define DT_NODE_HAS_STATUS_INTERNAL(node_id, status) \
+	IS_ENABLED(DT_CAT(node_id, _STATUS_ ## status))
+/** @internal helper for test cases and DT_ANY_INST_ON_BUS_STATUS_OKAY() */
+#define DT_COMPAT_ON_BUS_INTERNAL(compat, bus) \
+	IS_ENABLED(UTIL_CAT(DT_CAT(DT_COMPAT_, compat), _BUS_##bus))
+
+#endif /* DEVICETREE_H */
diff --git a/framework/include/fwk_dt_bindings.h b/framework/include/fwk_dt_bindings.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e23dcec2b8f508ba18ba5e8bd7185f4520de4fd
--- /dev/null
+++ b/framework/include/fwk_dt_bindings.h
@@ -0,0 +1,21 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2021, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef FWK_DT_BINDINGS_H
+#define FWK_DT_BINDINGS_H
+
+/* 
+ * Auto generated module indexes for Device tree inclusion.
+ * Match indices in main C code.
+ */
+#include "fwk_dt_bindings_gen.h"
+
+/* Additional module bindings for DTS use */
+
+
+
+#endif /* FWK_DT_BINDINGS_H */
diff --git a/framework/include/fwk_dt_bindings_gen.h.in b/framework/include/fwk_dt_bindings_gen.h.in
new file mode 100644
index 0000000000000000000000000000000000000000..d36a28d0bd285fa1e515a89c2b2c8d991583b5f6
--- /dev/null
+++ b/framework/include/fwk_dt_bindings_gen.h.in
@@ -0,0 +1,17 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2021, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef FWK_DT_BINDINGS_GEN_H
+#define FWK_DT_BINDINGS_GEN_H
+
+/* 
+ * Auto generated module indexes for Device tree inclusion.
+ * Match indices in main C code.
+ */
+@SCP_MODULE_DT_BINDING_IDX@
+
+#endif /* FWK_DT_BINDINGS_GEN_H */
diff --git a/framework/include/fwk_dt_config_dyn.h.in b/framework/include/fwk_dt_config_dyn.h.in
new file mode 100644
index 0000000000000000000000000000000000000000..9f1c23a7f9210d49cb603bae2b1739ac8f6aed8b
--- /dev/null
+++ b/framework/include/fwk_dt_config_dyn.h.in
@@ -0,0 +1,20 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2021, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+#ifndef FWK_DT_CONFIG_DYN_H
+#define FWK_DT_CONFIG_DYN_H
+
+/* 
+ * Auto generated dynamic configuration callbacks for dts configured modules
+ * Common module config calls dyn_get_element_table_<module>(), which is provided
+ * by the product specific module code.
+ * 
+ * Product specific code uses _static_get_element_table() to reference the element
+ * table defined by device tree macros in the common code.
+ */
+@SCP_MODULE_DT_DYN_CONFIG@
+
+#endif /* FWK_DT_CONFIG_DYN_H */
diff --git a/module/pl011/CMakeLists.txt b/module/pl011/CMakeLists.txt
index 27a2799a44f985faee2f4c36fdc1cf27aa0dae07..db2bc68e39259a4b3780c485bc2b63b309d565f1 100644
--- a/module/pl011/CMakeLists.txt
+++ b/module/pl011/CMakeLists.txt
@@ -13,6 +13,11 @@ target_include_directories(${SCP_MODULE_TARGET}
 target_sources(${SCP_MODULE_TARGET}
                PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src/mod_pl011.c")
 
+if(SCP_MODULE IN_LIST SCP_DT_CONFIG_MODULES_ALL)
+    target_sources(${SCP_MODULE_TARGET}
+                    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src/config_dt_pl011.c")
+endif()
+
 if("clock" IN_LIST SCP_MODULES)
     target_link_libraries(${SCP_MODULE_TARGET} PRIVATE module-clock)
 endif()
diff --git a/module/pl011/src/config_dt_pl011.c b/module/pl011/src/config_dt_pl011.c
new file mode 100644
index 0000000000000000000000000000000000000000..e42b0bbe3c015c9c92ef553915df05079cd6bbc2
--- /dev/null
+++ b/module/pl011/src/config_dt_pl011.c
@@ -0,0 +1,110 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2021, Linaro Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <mod_pl011.h>
+
+#include <fwk_element.h>
+#include <fwk_id.h>
+#include <fwk_macros.h>
+#include <fwk_module.h>
+#include <fwk_module_idx.h>
+#include <fwk_devicetree.h>
+#include <fwk_dt_config.h>
+#include <fwk_dt_config_dyn.h>
+
+
+#define PL011_COMPAT arm_pl011
+
+#define PL011_PROP(n, prop) DT_PROP(DT_INST(n, PL011_COMPAT), prop)
+
+#ifdef BUILD_HAS_MOD_CLOCK
+
+#define CFG_PL011_ELEMENT_DATA(n) \
+    .reg_base = DT_REG_ADDR_BY_IDX(DT_INST(n, PL011_COMPAT), 0),    \
+    .baud_rate_bps = PL011_PROP(n, current_speed), \
+    .clock_rate_hz = PL011_PROP(n, clock_frequency), \
+    .clock_id = FWK_ID_NONE_INIT, \
+    .pd_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_POWER_DOMAIN, \
+                                 PL011_PROP(n, pd_id) \
+                                 ),
+
+#else
+
+#define CFG_PL011_ELEMENT_DATA(n)                                   \
+    .reg_base = DT_REG_ADDR_BY_IDX(DT_INST(n, PL011_COMPAT), 0),    \
+    .baud_rate_bps = PL011_PROP(n, current_speed), \
+    .clock_rate_hz = PL011_PROP(n, clock_frequency), \
+    .pd_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_POWER_DOMAIN, \
+                                 PL011_PROP(n, pd_id) \
+                                 ),
+
+#endif
+
+#define CFG_PL011_ELEMENT_INIT(n) \
+    [n] = { \
+        .name = PL011_PROP(n, label), \
+        .data = &(struct mod_pl011_element_cfg) { \
+            CFG_PL011_ELEMENT_DATA(n)             \
+        },                                        \
+   },
+
+/* data table */
+static struct fwk_element pl011_element_table[] = {
+            // Macro for array elements
+            DT_FOREACH_OKAY_INST_arm_pl011(CFG_PL011_ELEMENT_INIT)
+            // last null element
+            [DT_N_INST_arm_pl011_NUM_OKAY] = { 0 },
+};
+
+
+/* access data table from dynamic element callback */
+#ifdef FWK_MODULE_GEN_DYNAMIC_PL011
+const struct fwk_element *_static_get_element_table_pl011() {
+    return pl011_element_table;
+}
+#endif
+
+/* config structure */
+struct fwk_module_config config_dt_pl011 = {
+    #ifdef FWK_MODULE_GEN_DYNAMIC_PL011
+    .elements = FWK_MODULE_DYNAMIC_ELEMENTS(dyn_get_element_table_pl011),
+    #else
+    .elements = FWK_MODULE_STATIC_ELEMENTS_PTR(pl011_element_table),
+    #endif
+};
+
+/*struct fwk_module_config config_dt_pl011 = {
+    .elements = FWK_MODULE_STATIC_ELEMENTS ({
+            // Macro for array elements
+            DT_FOREACH_OKAY_INST_arm_pl011(CFG_PL011_ELEMENT_INIT)
+                // last null element
+            [DT_N_INST_arm_pl011_NUM_OKAY] = { 0 },
+    }),
+};
+*/          
+
+/* - original declaration in juno pl011 
+struct fwk_module_config config_pl011 = {
+    .elements = FWK_MODULE_STATIC_ELEMENTS({
+        [0] = {
+            .name = "",
+            .data =
+                &(struct mod_pl011_element_cfg){
+                    .reg_base = FPGA_UART1_BASE,
+                    .baud_rate_bps = 115200,
+                    .clock_rate_hz = 24 * FWK_MHZ,
+                    .clock_id = FWK_ID_NONE_INIT,
+                    .pd_id = FWK_ID_ELEMENT_INIT(
+                        FWK_MODULE_IDX_POWER_DOMAIN,
+                        POWER_DOMAIN_IDX_SYSTOP),
+                },
+        },
+
+        [1] = { 0 },
+    }),
+};
+*/
diff --git a/product/juno/include/juno_dt_bindings.h b/product/juno/include/juno_dt_bindings.h
new file mode 100644
index 0000000000000000000000000000000000000000..fd313d5a141b4b125337ae8beb1da400f38d1d75
--- /dev/null
+++ b/product/juno/include/juno_dt_bindings.h
@@ -0,0 +1,33 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2019-2021, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef JUNO_DT_BINDINGS_H
+#define JUNO_DT_BINDINGS_H
+
+#include "juno_mmap.h"
+
+/* Level 0 */
+#define POWER_DOMAIN_IDX_BIG_CPU0       0
+#define POWER_DOMAIN_IDX_BIG_CPU1       1
+#define POWER_DOMAIN_IDX_LITTLE_CPU0    2
+#define POWER_DOMAIN_IDX_LITTLE_CPU1    3
+#define POWER_DOMAIN_IDX_LITTLE_CPU2    4
+#define POWER_DOMAIN_IDX_LITTLE_CPU3    5
+
+    /* Level 1 */
+#define POWER_DOMAIN_IDX_BIG_SSTOP      6
+#define POWER_DOMAIN_IDX_LITTLE_SSTOP   7
+#define POWER_DOMAIN_IDX_DBGSYS         8
+#define POWER_DOMAIN_IDX_GPUTOP         9
+
+    /* Level 2 */
+#define POWER_DOMAIN_IDX_SYSTOP         10
+
+#define POWER_DOMAIN_IDX_NONE           -1
+
+
+#endif /* JUNO_DT_BINDINGS_H */
diff --git a/product/juno/include/juno_mmap.h b/product/juno/include/juno_mmap.h
index 59911a85868c46cff3617384500db98dbb152d0e..458655b2540964afe1e272e7e2726b3b1288be2a 100644
--- a/product/juno/include/juno_mmap.h
+++ b/product/juno/include/juno_mmap.h
@@ -13,8 +13,6 @@
 
 #include "system_mmap.h"
 
-#include <stdint.h>
-
 #define I2C_BASE                    (VENDOR_EXTENSION_BASE + 0x00000000)
 #define PVT_AON_BASE                (VENDOR_EXTENSION_BASE + 0x00001000)
 #define SCC_BASE                    (VENDOR_EXTENSION_BASE + 0x1FEFF000)
diff --git a/product/juno/include/system_mmap.h b/product/juno/include/system_mmap.h
index 80524fd1b3201f54728648c9160c68d4e6812834..4e455d5af4b3da68de17ef629acc62ea9c6f003f 100644
--- a/product/juno/include/system_mmap.h
+++ b/product/juno/include/system_mmap.h
@@ -11,7 +11,11 @@
 #ifndef SYSTEM_MMAP_H
 #define SYSTEM_MMAP_H
 
+#ifndef DTS_COMPILE
 #include <stdint.h>
+#else
+#define UINT32_C(n) n
+#endif
 
 #define PERIPHERAL_BASE           UINT32_C(0x44000000)
 #define EXTERNAL_RAM_BASE         UINT32_C(0x60000000)
diff --git a/product/juno/scp_ramfw/CMakeLists.txt b/product/juno/scp_ramfw/CMakeLists.txt
index 7276343936fb655b30ca8c94b07d586b22ec3e03..1dd60712e09a2d1251bdea0c0cf2194655b08702 100644
--- a/product/juno/scp_ramfw/CMakeLists.txt
+++ b/product/juno/scp_ramfw/CMakeLists.txt
@@ -17,10 +17,13 @@ target_include_directories(
 
 # cmake-lint: disable=E1122
 
+#            "${CMAKE_CURRENT_SOURCE_DIR}/config_pl011.c"
+
+
 target_sources(
     juno-bl2
     PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/config_sds.c"
-            "${CMAKE_CURRENT_SOURCE_DIR}/config_pl011.c"
+            "${CMAKE_CURRENT_SOURCE_DIR}/config_dt_juno_pl011.c"
             "${CMAKE_CURRENT_SOURCE_DIR}/config_juno_soc_clock_ram.c"
             "${CMAKE_CURRENT_SOURCE_DIR}/config_clock.c"
             "${CMAKE_CURRENT_SOURCE_DIR}/config_dvfs.c"
@@ -121,4 +124,4 @@ if(SCP_ENABLE_STATISTICS)
 endif()
 
 set(SCP_MODULES ${SCP_MODULES} PARENT_SCOPE)
-set(SCP_MODULE_PATHS ${SCP_MODULE_PATHS} PARENT_SCOPE)
\ No newline at end of file
+set(SCP_MODULE_PATHS ${SCP_MODULE_PATHS} PARENT_SCOPE)
diff --git a/product/juno/scp_ramfw/Firmware.cmake b/product/juno/scp_ramfw/Firmware.cmake
index 06d99869469804eb0eea959d67ea6ff2cca28118..d743dd24570af75d7e2450993bf12b2898b248ee 100644
--- a/product/juno/scp_ramfw/Firmware.cmake
+++ b/product/juno/scp_ramfw/Firmware.cmake
@@ -34,6 +34,10 @@ set(SCP_ENABLE_IPO_INIT FALSE)
 
 set(SCP_ENABLE_PMI_INIT FALSE)
 
+set(SCP_FIRMWARE_DTS_SOURCE "${CMAKE_CURRENT_LIST_DIR}/../src/juno-scp.dts")
+
+list(PREPEND SCP_FIRMWARE_DTS_INCLUDE "${CMAKE_CURRENT_LIST_DIR}/../include")
+
 list(PREPEND SCP_MODULE_PATHS
      "${CMAKE_CURRENT_LIST_DIR}/../module/juno_reset_domain")
 list(PREPEND SCP_MODULE_PATHS
@@ -105,3 +109,8 @@ list(APPEND SCP_MODULES "mock-psu")
 list(APPEND SCP_MODULES "juno-pvt")
 list(APPEND SCP_MODULES "juno-thermal")
 list(APPEND SCP_MODULES "mock-clock")
+
+# select device tree configured modules
+# These use the .dts configured variants 
+#list(APPEND SCP_DT_CONFIG_MODULES_STD "clock")
+list(APPEND SCP_DT_CONFIG_MODULES_DYN "pl011")
\ No newline at end of file
diff --git a/product/juno/scp_ramfw/config_dt_juno_pl011.c b/product/juno/scp_ramfw/config_dt_juno_pl011.c
new file mode 100644
index 0000000000000000000000000000000000000000..856e845f65b634f0a3cd9a62e2d0cdee92372c58
--- /dev/null
+++ b/product/juno/scp_ramfw/config_dt_juno_pl011.c
@@ -0,0 +1,21 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2019-2021, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+
+#include <fwk_element.h>
+#include <fwk_id.h>
+#include <fwk_dt_config_dyn.h>
+
+
+/* example dynamic module config table implementation function */
+#ifdef FWK_MODULE_GEN_DYNAMIC_PL011
+const struct fwk_element *dyn_get_element_table_pl011(fwk_id_t module_id)
+{
+    /* in this case we are simple going to return the static table */
+    return _static_get_element_table_pl011();
+}
+#endif
diff --git a/product/juno/src/juno-scp.dts b/product/juno/src/juno-scp.dts
new file mode 100644
index 0000000000000000000000000000000000000000..66b5857a6414fc5c48e69aae3e343837b6c72ad1
--- /dev/null
+++ b/product/juno/src/juno-scp.dts
@@ -0,0 +1,15 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2021, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include "juno-scp-base.dtsi"
+
+/ {
+	model = "Juno Development Platform (r0-r2)";
+	compatible = "arm,juno";
+
+
+};
\ No newline at end of file
diff --git a/tools/dts/README.txt b/tools/dts/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..65fd39c4463cdb3fef642bc712857b36432820de
--- /dev/null
+++ b/tools/dts/README.txt
@@ -0,0 +1,10 @@
+Device tree scripts
+-------------------
+
+These device tree scripts are at present copied over from the Zephyr project,
+in order to add DT capabilities to the SCP build process.
+(zephyr/scripts/dts)/
+
+The libraries are at some point going to become standalone (see README_from_Zephyr.txt),
+at which point this project can grab them from the new repository, or
+come up with a better process for taking them from the Zephyr project.
diff --git a/tools/dts/dt_gen_config.py b/tools/dts/dt_gen_config.py
new file mode 100755
index 0000000000000000000000000000000000000000..f24d0176b26014676134303781f167a2ddbf616b
--- /dev/null
+++ b/tools/dts/dt_gen_config.py
@@ -0,0 +1,762 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2019 Linaro Limited
+# SPDX-License-Identifier: BSD-3-Clause
+
+# This script takes some code from zephyr gen_defines.py and also
+# uses edtlib from the Zephyr projct to generate module
+# config code from a devicetree (.dts) file.
+# Information from binding files in YAML format is used as well.
+#
+# Bindings are files that describe devicetree nodes. Devicetree nodes are
+# usually mapped to bindings via their 'compatible = "..."' property.
+#
+
+import argparse
+from collections import defaultdict
+import os
+import pathlib
+import re
+import sys
+
+# make the local version of the python devicetree module visible
+sys.path.append(os.path.join(os.path.dirname(__file__), 'python-devicetree',
+                             'src'))
+
+# use the zephyr dts editlib library 
+from devicetree import edtlib
+
+# The set of binding types whose values can be iterated over with
+# DT_FOREACH_PROP_ELEM(). If you change this, make sure to update the
+# doxygen string for that macro.
+FOREACH_PROP_ELEM_TYPES = set(['string', 'array', 'uint8-array', 'string-array',
+                               'phandles', 'phandle-array'])
+
+##
+## main processing loop
+##
+
+def main():
+    global header_file
+    global scp_base_dir
+
+    scp_base_dir = None
+    
+    args = parse_input()
+    if args.verbose:
+        print("Generating code from device tree files")
+        print("using:dts in; ", args.dts)
+        print("     :dts out; ", args.dts_out)
+        print("     :header out; ", args.header_out)
+        print("     :bindings dirs; ", args.bindings_dirs)
+        print("     :edt pickle out; ", args.edt_pickle_out)
+        print("     :vendor prefix; ", args.vendor_prefixes)
+        print("     :dtc flags; ", args.dtc_flags)
+        print("     :scp_base_dir; ",args.scp_base_dir)
+        print(" sys.path=", sys.path)
+
+    if args.vendor_prefixes:
+        vendor_prefixes = edtlib.load_vendor_prefixes_txt(args.vendor_prefixes)
+    else:
+        vendor_prefixes = None
+
+    if args.dtc_flags:
+        warn_reg_addr = "-Wno-simple_bus_reg" not in args.dtc_flags
+    else:
+        warn_reg_addr = True
+
+
+    if args.scp_base_dir:
+        scp_base_dir = args.scp_base_dir
+    
+    try:
+        edt = edtlib.EDT(args.dts, args.bindings_dirs,
+                         # Suppress this warning if it's suppressed in dtc
+                         warn_reg_unit_address_mismatch=warn_reg_addr,
+                         default_prop_types=True,
+                         infer_binding_for_paths=["/zephyr,user"],
+                         werror=args.edtlib_Werror,
+                         vendor_prefixes=vendor_prefixes)
+    except edtlib.EDTError as e:
+        sys.exit(f"devicetree error: {e}")
+
+    flash_area_num = 0
+
+    # Save merged DTS source, as a debugging aid
+    with open(args.dts_out, "w", encoding="utf-8") as f:
+        print(edt.dts_source, file=f)
+
+    # The raw index into edt.compat2nodes[compat] is used for node
+    # instance numbering within a compatible.
+    #
+    # As a way to satisfy people's intuitions about instance numbers,
+    # though, we sort this list so enabled instances come first.
+    #
+    # This might look like a hack, but it keeps drivers and
+    # applications which don't use instance numbers carefully working
+    # as expected, since e.g. instance number 0 is always the
+    # singleton instance if there's just one enabled node of a
+    # particular compatible.
+    #
+    # This doesn't violate any devicetree.h API guarantees about
+    # instance ordering, since we make no promises that instance
+    # numbers are stable across builds.
+    for compat, nodes in edt.compat2nodes.items():
+        edt.compat2nodes[compat] = sorted(
+            nodes, key=lambda node: 0 if node.status == "okay" else 1)
+
+    # Create the generated header.
+    with open(args.header_out, "w", encoding="utf-8") as header_file:
+        write_top_comment(edt)
+
+        # populate all z_path_id first so any children references will
+        # work correctly.
+        for node in sorted(edt.nodes, key=lambda node: node.dep_ordinal):
+            node.z_path_id = node_z_path_id(node)
+
+        for node in sorted(edt.nodes, key=lambda node: node.dep_ordinal):
+            write_node_comment(node)
+
+            out_comment("Node's full path:")
+            out_dt_define(f"{node.z_path_id}_PATH", f'"{escape(node.path)}"')
+
+            out_comment("Node's name with unit-address:")
+            out_dt_define(f"{node.z_path_id}_FULL_NAME",
+                          f'"{escape(node.name)}"')
+
+            if node.parent is not None:
+                out_comment(f"Node parent ({node.parent.path}) identifier:")
+                out_dt_define(f"{node.z_path_id}_PARENT",
+                              f"DT_{node.parent.z_path_id}")
+
+            write_child_functions(node)
+            write_child_functions_status_okay(node)
+            write_dep_info(node)
+            write_idents_and_existence(node)
+            write_bus(node)
+            write_special_props(node)
+            write_vanilla_props(node)
+
+        write_chosen(edt)
+        write_global_compat_info(edt)
+        extern_header = args.header_out + ".extern"
+        write_device_extern_header(extern_header, edt)
+            
+##
+## write (node) functions
+##
+
+def write_bus(node):
+    # Macros about the node's bus controller, if there is one
+
+    bus = node.bus_node
+    if not bus:
+        return
+
+    if not bus.label:
+        err(f"missing 'label' property on bus node {bus!r}")
+
+    out_comment(f"Bus info (controller: '{bus.path}', type: '{node.on_bus}')")
+    out_dt_define(f"{node.z_path_id}_BUS_{str2ident(node.on_bus)}", 1)
+    out_dt_define(f"{node.z_path_id}_BUS", f"DT_{bus.z_path_id}")
+
+
+def write_special_props(node):
+    # Writes required macros for special case properties, when the
+    # data cannot otherwise be obtained from write_vanilla_props()
+    # results
+
+    global flash_area_num
+
+    out_comment("Special property macros:")
+
+    # Macros that are special to the devicetree specification
+    write_regs(node)
+#    write_interrupts(node)
+    write_compatibles(node)
+#    write_status(node)
+
+#    if node.parent and "fixed-partitions" in node.parent.compats:
+#        macro = f"{node.z_path_id}_PARTITION_ID"
+#        out_dt_define(macro, flash_area_num)
+#        flash_area_num += 1
+
+def write_vanilla_props(node):
+    # Writes macros for any and all properties defined in the
+    # "properties" section of the binding for the node.
+    #
+    # This does generate macros for special properties as well, like
+    # regs, etc. Just let that be rather than bothering to add
+    # never-ending amounts of special case code here to skip special
+    # properties. This function's macros can't conflict with
+    # write_special_props() macros, because they're in different
+    # namespaces. Special cases aren't special enough to break the rules.
+
+    macro2val = {}
+    for prop_name, prop in node.props.items():
+        prop_id = str2ident(prop_name)
+        macro = f"{node.z_path_id}_P_{prop_id}"
+        val = prop2value(prop)
+        if val is not None:
+            # DT_N_<node-id>_P_<prop-id>
+            macro2val[macro] = val
+
+        if prop.spec.type == 'string':
+            macro2val[macro + "_STRING_TOKEN"] = prop.val_as_token
+            macro2val[macro + "_STRING_UPPER_TOKEN"] = prop.val_as_token.upper()
+
+        if prop.enum_index is not None:
+            # DT_N_<node-id>_P_<prop-id>_ENUM_IDX
+            macro2val[macro + "_ENUM_IDX"] = prop.enum_index
+            spec = prop.spec
+
+            if spec.enum_tokenizable:
+                as_token = prop.val_as_token
+
+                # DT_N_<node-id>_P_<prop-id>_ENUM_TOKEN
+                macro2val[macro + "_ENUM_TOKEN"] = as_token
+
+                if spec.enum_upper_tokenizable:
+                    # DT_N_<node-id>_P_<prop-id>_ENUM_UPPER_TOKEN
+                    macro2val[macro + "_ENUM_UPPER_TOKEN"] = as_token.upper()
+
+        if "phandle" in prop.type:
+            macro2val.update(phandle_macros(prop, macro))
+        elif "array" in prop.type:
+            # DT_N_<node-id>_P_<prop-id>_IDX_<i>
+            # DT_N_<node-id>_P_<prop-id>_IDX_<i>_EXISTS
+            for i, subval in enumerate(prop.val):
+                if isinstance(subval, str):
+                    macro2val[macro + f"_IDX_{i}"] = quote_str(subval)
+                else:
+                    macro2val[macro + f"_IDX_{i}"] = subval
+                macro2val[macro + f"_IDX_{i}_EXISTS"] = 1
+
+        if prop.type in FOREACH_PROP_ELEM_TYPES:
+            # DT_N_<node-id>_P_<prop-id>_FOREACH_PROP_ELEM
+            macro2val[f"{macro}_FOREACH_PROP_ELEM(fn)"] = \
+                ' \\\n\t'.join(f'fn(DT_{node.z_path_id}, {prop_id}, {i})'
+                              for i in range(len(prop.val)))
+
+            macro2val[f"{macro}_FOREACH_PROP_ELEM_VARGS(fn, ...)"] = \
+                ' \\\n\t'.join(f'fn(DT_{node.z_path_id}, {prop_id}, {i},'
+                                ' __VA_ARGS__)'
+                              for i in range(len(prop.val)))
+
+        plen = prop_len(prop)
+        if plen is not None:
+            # DT_N_<node-id>_P_<prop-id>_LEN
+            macro2val[macro + "_LEN"] = plen
+
+        macro2val[f"{macro}_EXISTS"] = 1
+
+    if macro2val:
+        out_comment("Generic property macros:")
+        for macro, val in macro2val.items():
+            out_dt_define(macro, val)
+    else:
+        out_comment("(No generic property macros)")
+
+
+
+def write_regs(node):
+    # reg property: edtlib knows the right #address-cells and
+    # #size-cells, and can therefore pack the register base addresses
+    # and sizes correctly
+
+    idx_vals = []
+    name_vals = []
+    path_id = node.z_path_id
+
+    if node.regs is not None:
+        idx_vals.append((f"{path_id}_REG_NUM", len(node.regs)))
+
+    for i, reg in enumerate(node.regs):
+        idx_vals.append((f"{path_id}_REG_IDX_{i}_EXISTS", 1))
+        if reg.addr is not None:
+            idx_macro = f"{path_id}_REG_IDX_{i}_VAL_ADDRESS"
+            idx_vals.append((idx_macro,
+                             f"{reg.addr} /* {hex(reg.addr)} */"))
+            if reg.name:
+                name_macro = f"{path_id}_REG_NAME_{reg.name}_VAL_ADDRESS"
+                name_vals.append((name_macro, f"DT_{idx_macro}"))
+
+        if reg.size is not None:
+            idx_macro = f"{path_id}_REG_IDX_{i}_VAL_SIZE"
+            idx_vals.append((idx_macro,
+                             f"{reg.size} /* {hex(reg.size)} */"))
+            if reg.name:
+                name_macro = f"{path_id}_REG_NAME_{reg.name}_VAL_SIZE"
+                name_vals.append((name_macro, f"DT_{idx_macro}"))
+
+    for macro, val in idx_vals:
+        out_dt_define(macro, val)
+    for macro, val in name_vals:
+        out_dt_define(macro, val)
+
+def write_compatibles(node):
+    # Writes a macro for each of the node's compatibles. We don't care
+    # about whether edtlib / Zephyr's binding language recognizes
+    # them. The compatibles the node provides are what is important.
+
+    for compat in node.compats:
+        out_dt_define(
+            f"{node.z_path_id}_COMPAT_MATCHES_{str2ident(compat)}", 1)
+
+def write_node_comment(node):
+    # Writes a comment describing 'node' to the header and configuration file
+
+    s = f"""\
+Devicetree node: {node.path}
+
+Node identifier: DT_{node.z_path_id}
+"""
+
+    if node.matching_compat:
+        if node.binding_path:
+            s += f"""
+Binding (compatible = {node.matching_compat}):
+  {relativize(node.binding_path)}
+"""
+        else:
+            s += f"""
+Binding (compatible = {node.matching_compat}):
+  No yaml (bindings inferred from properties)
+"""
+
+    if node.description:
+        # We used to put descriptions in the generated file, but
+        # devicetree bindings now have pages in the HTML
+        # documentation. Let users who are accustomed to digging
+        # around in the generated file where to find the descriptions
+        # now.
+        #
+        # Keeping them here would mean that the descriptions
+        # themselves couldn't contain C multi-line comments, which is
+        # inconvenient when we want to do things like quote snippets
+        # of .dtsi files within the descriptions, or otherwise
+        # include the string "*/".
+        s += ("\n(Descriptions have moved to the Devicetree Bindings Index\n"
+              "in the documentation.)\n")
+
+    out_comment(s)
+    
+def write_child_functions(node):
+    # Writes macro that are helpers that will call a macro/function
+    # for each child node.
+
+    out_dt_define(f"{node.z_path_id}_FOREACH_CHILD(fn)",
+            " ".join(f"fn(DT_{child.z_path_id})" for child in
+                node.children.values()))
+
+    out_dt_define(f"{node.z_path_id}_FOREACH_CHILD_VARGS(fn, ...)",
+            " ".join(f"fn(DT_{child.z_path_id}, __VA_ARGS__)" for child in
+                node.children.values()))
+
+def write_child_functions_status_okay(node):
+    # Writes macro that are helpers that will call a macro/function
+    # for each child node with status "okay".
+
+    functions = ''
+    functions_args = ''
+    for child in node.children.values():
+        if child.status == "okay":
+            functions = functions + f"fn(DT_{child.z_path_id}) "
+            functions_args = functions_args + f"fn(DT_{child.z_path_id}, " \
+                                                            "__VA_ARGS__) "
+
+    out_dt_define(f"{node.z_path_id}_FOREACH_CHILD_STATUS_OKAY(fn)", functions)
+    out_dt_define(f"{node.z_path_id}_FOREACH_CHILD_STATUS_OKAY_VARGS(fn, ...)",
+                                                                functions_args)
+
+
+def write_idents_and_existence(node):
+    # Writes macros related to the node's aliases, labels, etc.,
+    # as well as existence flags.
+
+    # Aliases
+    idents = [f"N_ALIAS_{str2ident(alias)}" for alias in node.aliases]
+    # Instances
+    for compat in node.compats:
+        instance_no = node.edt.compat2nodes[compat].index(node)
+        idents.append(f"N_INST_{instance_no}_{str2ident(compat)}")
+    # Node labels
+    idents.extend(f"N_NODELABEL_{str2ident(label)}" for label in node.labels)
+
+    out_comment("Existence and alternate IDs:")
+    out_dt_define(node.z_path_id + "_EXISTS", 1)
+
+    # Only determine maxlen if we have any idents
+    if idents:
+        maxlen = max(len("DT_" + ident) for ident in idents)
+    for ident in idents:
+        out_dt_define(ident, "DT_" + node.z_path_id, width=maxlen)
+
+def write_dep_info(node):
+    # Write dependency-related information about the node.
+
+    def fmt_dep_list(dep_list):
+        if dep_list:
+            # Sort the list by dependency ordinal for predictability.
+            sorted_list = sorted(dep_list, key=lambda node: node.dep_ordinal)
+            return "\\\n\t" + \
+                " \\\n\t".join(f"{n.dep_ordinal}, /* {n.path} */"
+                               for n in sorted_list)
+        else:
+            return "/* nothing */"
+
+    out_comment("Node's dependency ordinal:")
+    out_dt_define(f"{node.z_path_id}_ORD", node.dep_ordinal)
+
+    out_comment("Ordinals for what this node depends on directly:")
+    out_dt_define(f"{node.z_path_id}_REQUIRES_ORDS",
+                  fmt_dep_list(node.depends_on))
+
+    out_comment("Ordinals for what depends directly on this node:")
+    out_dt_define(f"{node.z_path_id}_SUPPORTS_ORDS",
+                  fmt_dep_list(node.required_by))
+
+##
+## write (edt) functions
+##
+
+def write_chosen(edt):
+    # Tree-wide information such as chosen nodes is printed here.
+
+    out_comment("Chosen nodes\n")
+    chosen = {}
+    for name, node in edt.chosen_nodes.items():
+        chosen[f"DT_CHOSEN_{str2ident(name)}"] = f"DT_{node.z_path_id}"
+        chosen[f"DT_CHOSEN_{str2ident(name)}_EXISTS"] = 1
+    max_len = max(map(len, chosen), default=0)
+    for macro, value in chosen.items():
+        out_define(macro, value, width=max_len)
+
+
+def write_global_compat_info(edt):
+    # Tree-wide information related to each compatible, such as number
+    # of instances with status "okay", is printed here.
+
+    n_okay_macros = {}
+    for_each_macros = {}
+    compat2buses = defaultdict(list)  # just for "okay" nodes
+    for compat, okay_nodes in edt.compat2okay.items():
+        for node in okay_nodes:
+            bus = node.on_bus
+            if bus is not None and bus not in compat2buses[compat]:
+                compat2buses[compat].append(bus)
+
+        ident = str2ident(compat)
+        n_okay_macros[f"DT_N_INST_{ident}_NUM_OKAY"] = len(okay_nodes)
+
+        # Helpers for non-INST for-each macros that take node
+        # identifiers as arguments.
+        for_each_macros[f"DT_FOREACH_OKAY_{ident}(fn)"] = \
+            " ".join(f"fn(DT_{node.z_path_id})"
+                     for node in okay_nodes)
+        for_each_macros[f"DT_FOREACH_OKAY_VARGS_{ident}(fn, ...)"] = \
+            " ".join(f"fn(DT_{node.z_path_id}, __VA_ARGS__)"
+                     for node in okay_nodes)
+
+        # Helpers for INST versions of for-each macros, which take
+        # instance numbers. We emit separate helpers for these because
+        # avoiding an intermediate node_id --> instance number
+        # conversion in the preprocessor helps to keep the macro
+        # expansions simpler. That hopefully eases debugging.
+        for_each_macros[f"DT_FOREACH_OKAY_INST_{ident}(fn)"] = \
+            " ".join(f"fn({edt.compat2nodes[compat].index(node)})"
+                     for node in okay_nodes)
+        for_each_macros[f"DT_FOREACH_OKAY_INST_VARGS_{ident}(fn, ...)"] = \
+            " ".join(f"fn({edt.compat2nodes[compat].index(node)}, __VA_ARGS__)"
+                     for node in okay_nodes)
+
+    for compat, nodes in edt.compat2nodes.items():
+        for node in nodes:
+            if compat == "fixed-partitions":
+                for child in node.children.values():
+                    if "label" in child.props:
+                        label = child.props["label"].val
+                        macro = f"COMPAT_{str2ident(compat)}_LABEL_{str2ident(label)}"
+                        val = f"DT_{child.z_path_id}"
+
+                        out_dt_define(macro, val)
+                        out_dt_define(macro + "_EXISTS", 1)
+
+    out_comment('Macros for compatibles with status "okay" nodes\n')
+    for compat, okay_nodes in edt.compat2okay.items():
+        if okay_nodes:
+            out_define(f"DT_COMPAT_HAS_OKAY_{str2ident(compat)}", 1)
+
+    out_comment('Macros for status "okay" instances of each compatible\n')
+    for macro, value in n_okay_macros.items():
+        out_define(macro, value)
+    for macro, value in for_each_macros.items():
+        out_define(macro, value)
+
+    out_comment('Bus information for status "okay" nodes of each compatible\n')
+    for compat, buses in compat2buses.items():
+        for bus in buses:
+            out_define(
+                f"DT_COMPAT_{str2ident(compat)}_BUS_{str2ident(bus)}", 1)
+
+    
+def write_top_comment(edt):
+    # Writes an overview comment with misc. info at the top of the header and
+    # configuration file
+
+    s = f"""\
+Generated by gen_defines.py
+
+DTS input file:
+  {edt.dts_path}
+
+Directories with bindings:
+  {", ".join(map(relativize, edt.bindings_dirs))}
+
+Node dependency ordering (ordinal and path):
+"""
+
+    for scc in edt.scc_order:
+        if len(scc) > 1:
+            err("cycle in devicetree involving "
+                + ", ".join(node.path for node in scc))
+        s += f"  {scc[0].dep_ordinal:<3} {scc[0].path}\n"
+
+    s += """
+Definitions derived from these nodes in dependency order are next,
+followed by /chosen nodes.
+"""
+
+    out_comment(s, blank_before=False)
+
+    ### not really used for SP but look to see what it does.
+def write_device_extern_header(device_header_out, edt):
+    # Generate header that will extern devicetree struct device's
+
+    with open(device_header_out, "w", encoding="utf-8") as dev_header_file:
+        print("#ifndef DEVICE_EXTERN_GEN_H", file=dev_header_file)
+        print("#define DEVICE_EXTERN_GEN_H", file=dev_header_file)
+        print("", file=dev_header_file)
+        print("#ifdef __cplusplus", file=dev_header_file)
+        print('extern "C" {', file=dev_header_file)
+        print("#endif", file=dev_header_file)
+        print("", file=dev_header_file)
+
+        for node in sorted(edt.nodes, key=lambda node: node.dep_ordinal):
+            print(f"extern const struct device DEVICE_DT_NAME_GET(DT_{node.z_path_id}); /* dts_ord_{node.dep_ordinal} */",
+                  file=dev_header_file)
+
+        print("", file=dev_header_file)
+        print("#ifdef __cplusplus", file=dev_header_file)
+        print("}", file=dev_header_file)
+        print("#endif", file=dev_header_file)
+        print("", file=dev_header_file)
+        print("#endif /* DEVICE_EXTERN_GEN_H */", file=dev_header_file)
+
+
+
+    
+##
+## out_ string functions
+##
+    
+def out_dt_define(macro, val, width=None, deprecation_msg=None):
+    # Writes "#define DT_<macro> <val>" to the header file
+    #
+    # The macro will be left-justified to 'width' characters if that
+    # is specified, and the value will follow immediately after in
+    # that case. Otherwise, this function decides how to add
+    # whitespace between 'macro' and 'val'.
+    #
+    # If a 'deprecation_msg' string is passed, the generated identifiers will
+    # generate a warning if used, via __WARN(<deprecation_msg>)).
+    #
+    # Returns the full generated macro for 'macro', with leading "DT_".
+    ret = "DT_" + macro
+    out_define(ret, val, width=width, deprecation_msg=deprecation_msg)
+    return ret
+
+
+def out_define(macro, val, width=None, deprecation_msg=None):
+    # Helper for out_dt_define(). Outputs "#define <macro> <val>",
+    # adds a deprecation message if given, and allocates whitespace
+    # unless told not to.
+
+    warn = fr' __WARN("{deprecation_msg}")' if deprecation_msg else ""
+
+    if width:
+        s = f"#define {macro.ljust(width)}{warn} {val}"
+    else:
+        s = f"#define {macro}{warn} {val}"
+
+    print(s, file=header_file)
+
+def out_comment(s, blank_before=True):
+    # Writes 's' as a comment to the header and configuration file. 's' is
+    # allowed to have multiple lines. blank_before=True adds a blank line
+    # before the comment.
+
+    if blank_before:
+        print(file=header_file)
+
+    if "\n" in s:
+        # Format multi-line comments like
+        #
+        #   /*
+        #    * first line
+        #    * second line
+        #    *
+        #    * empty line before this line
+        #    */
+        res = ["/*"]
+        for line in s.splitlines():
+            # Avoid an extra space after '*' for empty lines. They turn red in
+            # Vim if space error checking is on, which is annoying.
+            res.append(" *" if not line.strip() else " * " + line)
+        res.append(" */")
+        print("\n".join(res), file=header_file)
+    else:
+        # Format single-line comments like
+        #
+        #   /* foo bar */
+        print("/* " + s + " */", file=header_file)
+
+##
+## general utility functions
+##
+
+def relativize(path):
+    # If 'path' is within scp_base_dir, returns it relative to scp_base_dir,
+    # with a "$ZEPHYR_BASE/..." hint at the start of the string. Otherwise,
+    # returns 'path' unchanged.
+
+    if scp_base_dir is None:
+        return path
+
+    try:
+        return str("SCP_BASE_DIR" / pathlib.Path(path).relative_to(scp_base_dir))
+    except ValueError:
+        # Not within ZEPHYR_BASE
+        return path
+
+def quote_str(s):
+    # Puts quotes around 's' and escapes any double quotes and
+    # backslashes within it
+
+    return f'"{escape(s)}"'
+def node_z_path_id(node):
+    # Return the node specific bit of the node's path identifier:
+    #
+    # - the root node's path "/" has path identifier "N"
+    # - "/foo" has "N_S_foo"
+    # - "/foo/bar" has "N_S_foo_S_bar"
+    # - "/foo/bar@123" has "N_S_foo_S_bar_123"
+    #
+    # This is used throughout this file to generate macros related to
+    # the node.
+
+    components = ["N"]
+    if node.parent is not None:
+        components.extend(f"S_{str2ident(component)}" for component in
+                          node.path.split("/")[1:])
+
+    return "_".join(components)
+
+def str2ident(s):
+    # Converts 's' to a form suitable for (part of) an identifier
+
+    return re.sub('[-,.@/+]', '_', s.lower())
+
+def escape(s):
+    # Backslash-escapes any double quotes and backslashes in 's'
+
+    # \ must be escaped before " to avoid double escaping
+    return s.replace("\\", "\\\\").replace('"', '\\"')
+
+def prop2value(prop):
+    # Gets the macro value for property 'prop', if there is
+    # a single well-defined C rvalue that it can be represented as.
+    # Returns None if there isn't one.
+
+    if prop.type == "string":
+        return quote_str(prop.val)
+
+    if prop.type == "int":
+        return prop.val
+
+    if prop.type == "boolean":
+        return 1 if prop.val else 0
+
+    if prop.type in ["array", "uint8-array"]:
+        return list2init(f"{val} /* {hex(val)} */" for val in prop.val)
+
+    if prop.type == "string-array":
+        return list2init(quote_str(val) for val in prop.val)
+
+    # phandle, phandles, phandle-array, path, compound: nothing
+    return None
+
+def prop_len(prop):
+    # Returns the property's length if and only if we should generate
+    # a _LEN macro for the property. Otherwise, returns None.
+    #
+    # This deliberately excludes reg and interrupts.
+    # While they have array type, their lengths as arrays are
+    # basically nonsense semantically due to #address-cells and
+    # #size-cells for "reg" and #interrupt-cells for "interrupts".
+    #
+    # We have special purpose macros for the number of register blocks
+    # / interrupt specifiers. Excluding them from this list means
+    # DT_PROP_LEN(node_id, ...) fails fast at the devicetree.h layer
+    # with a build error. This forces users to switch to the right
+    # macros.
+
+    if prop.type == "phandle":
+        return 1
+
+    if (prop.type in ["array", "uint8-array", "string-array",
+                      "phandles", "phandle-array"] and
+                prop.name not in ["reg", "interrupts"]):
+        return len(prop.val)
+
+    return None
+
+def list2init(l):
+    # Converts 'l', a Python list (or iterable), to a C array initializer
+
+    return "{" + ", ".join(l) + "}"
+
+##
+## input options
+##
+
+def parse_input():
+    # parse the command line arguments
+    parser = argparse.ArgumentParser();
+    parser.add_argument("--dts", required=True, help ="The input .dts file")
+    parser.add_argument("--bindings-dirs", nargs='+', required=True,
+                        help="directory with bindings in YAML format, "
+                        "we allow multiple")
+    parser.add_argument("--header-out", required=True,
+                        help="path and filename to write header to")
+    parser.add_argument("--dts-out", required=True,
+                        help="path to write merged DTS source code to (e.g. "
+                             "as a debugging aid)")
+    parser.add_argument("--edt-pickle-out",
+                        help="path to write pickled edtlib.EDT object to")
+    parser.add_argument("--vendor-prefixes",
+                        help="vendor-prefixes.txt path; used for validation")
+    parser.add_argument("--dtc-flags",
+                        help="'dtc' devicetree compiler flags, some of which "
+                             "might be respected here")
+    parser.add_argument("--verbose", help="extra script logging for debug")
+    parser.add_argument("--edtlib-Werror", action="store_true",
+                        help="if set, edtlib-specific warnings become errors. "
+                             "(this does not apply to warnings shared "
+                             "with dtc.)")
+    parser.add_argument("--scp-base-dir")
+    return parser.parse_args()
+
+# put in the main guard
+if __name__ == "__main__":
+    main()
diff --git a/tools/dts/python-devicetree/.gitignore b/tools/dts/python-devicetree/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..20574a34569ec420ec253a9d71e31f075b06f55e
--- /dev/null
+++ b/tools/dts/python-devicetree/.gitignore
@@ -0,0 +1,7 @@
+dist/
+src/devicetree.egg-info/
+build/
+devicetree.egg-info/
+__pycache__/
+.tox/
+doc/build/
diff --git a/tools/dts/python-devicetree/requirements.txt b/tools/dts/python-devicetree/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f827ad8d1d68a48da5427961cafb473c45241bcd
--- /dev/null
+++ b/tools/dts/python-devicetree/requirements.txt
@@ -0,0 +1 @@
+sphinx_rtd_theme                # docs
diff --git a/tools/dts/python-devicetree/setup.py b/tools/dts/python-devicetree/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..590ba3151048d87c92213dddbd21a90bed0ace1e
--- /dev/null
+++ b/tools/dts/python-devicetree/setup.py
@@ -0,0 +1,42 @@
+# Copyright (c) 2021, Nordic Semiconductor ASA
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import setuptools
+
+long_description = '''
+Placeholder
+===========
+
+This is just a placeholder for moving Zephyr's devicetree libraries
+to PyPI.
+'''
+
+version = '0.0.1'
+
+setuptools.setup(
+    # TBD, just use these for now.
+    author='Zephyr Project',
+    author_email='devel@lists.zephyrproject.org',
+
+    name='devicetree',
+    version=version,
+    description='Python libraries for devicetree',
+    long_description=long_description,
+    # http://docutils.sourceforge.net/FAQ.html#what-s-the-official-mime-type-for-restructuredtext-data
+    long_description_content_type="text/x-rst",
+    url='https://github.com/zephyrproject-rtos/python-devicetree',
+    packages=setuptools.find_packages(where='src'),
+    package_dir={'': 'src'},
+    classifiers=[
+        'Programming Language :: Python :: 3 :: Only',
+        'License :: OSI Approved :: Apache Software License',
+        'Operating System :: POSIX :: Linux',
+        'Operating System :: MacOS :: MacOS X',
+        'Operating System :: Microsoft :: Windows',
+    ],
+    install_requires=[
+        'PyYAML>=5.1',
+    ],
+    python_requires='>=3.6',
+)
diff --git a/tools/dts/python-devicetree/src/devicetree/__init__.py b/tools/dts/python-devicetree/src/devicetree/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9a568330b68a521836a79cdc15b1fc369acfa37
--- /dev/null
+++ b/tools/dts/python-devicetree/src/devicetree/__init__.py
@@ -0,0 +1,4 @@
+# Copyright (c) 2021 Nordic Semiconductor ASA
+# SPDX-License-Identifier: Apache-2.0
+
+__all__ = ['edtlib', 'dtlib']
diff --git a/tools/dts/python-devicetree/src/devicetree/dtlib.py b/tools/dts/python-devicetree/src/devicetree/dtlib.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d5f32cf711683c2b249faf41b18a2964f69ba4c
--- /dev/null
+++ b/tools/dts/python-devicetree/src/devicetree/dtlib.py
@@ -0,0 +1,2026 @@
+# Copyright (c) 2019, Nordic Semiconductor
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Tip: You can view just the documentation with 'pydoc3 devicetree.dtlib'
+
+# _init_tokens() builds names dynamically.
+#
+# pylint: disable=undefined-variable
+
+"""
+A library for extracting information from .dts (devicetree) files. See the
+documentation for the DT and Node classes for more information.
+
+The top-level entry point of the library is the DT class. DT.__init__() takes a
+.dts file to parse and a list of directories to search for any /include/d
+files.
+"""
+
+import collections
+import enum
+import errno
+import os
+import re
+import sys
+import textwrap
+from typing import Any, Dict, Iterable, List, \
+    NamedTuple, NoReturn, Optional, Tuple, Union
+
+# NOTE: tests/test_dtlib.py is the test suite for this library.
+
+class DTError(Exception):
+    "Exception raised for devicetree-related errors"
+
+class Node:
+    r"""
+    Represents a node in the devicetree ('node-name { ... };').
+
+    These attributes are available on Node instances:
+
+    name:
+      The name of the node (a string).
+
+    unit_addr:
+      The portion after the '@' in the node's name, or the empty string if the
+      name has no '@' in it.
+
+      Note that this is a string. Run int(node.unit_addr, 16) to get an
+      integer.
+
+    props:
+      A collections.OrderedDict that maps the properties defined on the node to
+      their values. 'props' is indexed by property name (a string), and values
+      are Property objects.
+
+      To convert property values to Python numbers or strings, use
+      dtlib.to_num(), dtlib.to_nums(), or dtlib.to_string().
+
+      Property values are represented as 'bytes' arrays to support the full
+      generality of DTS, which allows assignments like
+
+        x = "foo", < 0x12345678 >, [ 9A ];
+
+      This gives x the value b"foo\0\x12\x34\x56\x78\x9A". Numbers in DTS are
+      stored in big-endian format.
+
+    nodes:
+      A collections.OrderedDict containing the subnodes of the node, indexed by
+      name.
+
+    labels:
+      A list with all labels pointing to the node, in the same order as the
+      labels appear, but with duplicates removed.
+
+      'label_1: label_2: node { ... };' gives 'labels' the value
+      ["label_1", "label_2"].
+
+    parent:
+      The parent Node of the node. 'None' for the root node.
+
+    path:
+      The path to the node as a string, e.g. "/foo/bar".
+
+    dt:
+      The DT instance this node belongs to.
+    """
+
+    #
+    # Public interface
+    #
+
+    def __init__(self, name: str, parent: Optional['Node'], dt: 'DT'):
+        """
+        Node constructor. Not meant to be called directly by clients.
+        """
+        self.name = name
+        self.parent = parent
+        self.dt = dt
+
+        self.props: Dict[str, 'Property'] = collections.OrderedDict()
+        self.nodes: Dict[str, 'Node'] = collections.OrderedDict()
+        self.labels: List[str] = []
+        self._omit_if_no_ref = False
+        self._is_referenced = False
+
+    @property
+    def unit_addr(self) -> str:
+        """
+        See the class documentation.
+        """
+        return self.name.partition("@")[2]
+
+    @property
+    def path(self) -> str:
+        """
+        See the class documentation.
+        """
+        node_names = []
+
+        cur = self
+        while cur.parent:
+            node_names.append(cur.name)
+            cur = cur.parent
+
+        return "/" + "/".join(reversed(node_names))
+
+    def node_iter(self) -> Iterable['Node']:
+        """
+        Returns a generator for iterating over the node and its children,
+        recursively.
+
+        For example, this will iterate over all nodes in the tree (like
+        dt.node_iter()).
+
+          for node in dt.root.node_iter():
+              ...
+        """
+        yield self
+        for node in self.nodes.values():
+            yield from node.node_iter()
+
+    def _get_prop(self, name: str) -> 'Property':
+        # Returns the property named 'name' on the node, creating it if it
+        # doesn't already exist
+
+        prop = self.props.get(name)
+        if not prop:
+            prop = Property(self, name)
+            self.props[name] = prop
+        return prop
+
+    def _del(self) -> None:
+        # Removes the node from the tree
+        self.parent.nodes.pop(self.name)  # type: ignore
+
+    def __str__(self):
+        """
+        Returns a DTS representation of the node. Called automatically if the
+        node is print()ed.
+        """
+        s = "".join(label + ": " for label in self.labels)
+
+        s += "{} {{\n".format(self.name)
+
+        for prop in self.props.values():
+            s += "\t" + str(prop) + "\n"
+
+        for child in self.nodes.values():
+            s += textwrap.indent(child.__str__(), "\t") + "\n"
+
+        s += "};"
+
+        return s
+
+    def __repr__(self):
+        """
+        Returns some information about the Node instance. Called automatically
+        if the Node instance is evaluated.
+        """
+        return "<Node {} in '{}'>" \
+               .format(self.path, self.dt.filename)
+
+# See Property.type
+class Type(enum.IntEnum):
+    EMPTY = 0
+    BYTES = 1
+    NUM = 2
+    NUMS = 3
+    STRING = 4
+    STRINGS = 5
+    PATH = 6
+    PHANDLE = 7
+    PHANDLES = 8
+    PHANDLES_AND_NUMS = 9
+    COMPOUND = 10
+
+class _MarkerType(enum.IntEnum):
+    # Types of markers in property values
+
+    # References
+    PATH = 0     # &foo
+    PHANDLE = 1  # <&foo>
+    LABEL = 2    # foo: <1 2 3>
+
+    # Start of data blocks of specific type
+    UINT8 = 3   # [00 01 02] (and also used for /incbin/)
+    UINT16 = 4  # /bits/ 16 <1 2 3>
+    UINT32 = 5  # <1 2 3>
+    UINT64 = 6  # /bits/ 64 <1 2 3>
+    STRING = 7  # "foo"
+
+class Property:
+    """
+    Represents a property ('x = ...').
+
+    These attributes are available on Property instances:
+
+    name:
+      The name of the property (a string).
+
+    value:
+      The value of the property, as a 'bytes' string. Numbers are stored in
+      big-endian format, and strings are null-terminated. Putting multiple
+      comma-separated values in an assignment (e.g., 'x = < 1 >, "foo"') will
+      concatenate the values.
+
+      See the to_*() methods for converting the value to other types.
+
+    type:
+      The type of the property, inferred from the syntax used in the
+      assignment. This is one of the following constants (with example
+      assignments):
+
+        Assignment                  | Property.type
+        ----------------------------+------------------------
+        foo;                        | dtlib.Type.EMPTY
+        foo = [];                   | dtlib.Type.BYTES
+        foo = [01 02];              | dtlib.Type.BYTES
+        foo = /bits/ 8 <1>;         | dtlib.Type.BYTES
+        foo = <1>;                  | dtlib.Type.NUM
+        foo = <>;                   | dtlib.Type.NUMS
+        foo = <1 2 3>;              | dtlib.Type.NUMS
+        foo = <1 2>, <3>;           | dtlib.Type.NUMS
+        foo = "foo";                | dtlib.Type.STRING
+        foo = "foo", "bar";         | dtlib.Type.STRINGS
+        foo = <&l>;                 | dtlib.Type.PHANDLE
+        foo = <&l1 &l2 &l3>;        | dtlib.Type.PHANDLES
+        foo = <&l1 &l2>, <&l3>;     | dtlib.Type.PHANDLES
+        foo = <&l1 1 2 &l2 3 4>;    | dtlib.Type.PHANDLES_AND_NUMS
+        foo = <&l1 1 2>, <&l2 3 4>; | dtlib.Type.PHANDLES_AND_NUMS
+        foo = &l;                   | dtlib.Type.PATH
+        *Anything else*             | dtlib.Type.COMPOUND
+
+      *Anything else* includes properties mixing phandle (<&label>) and node
+      path (&label) references with other data.
+
+      Data labels in the property value do not influence the type.
+
+    labels:
+      A list with all labels pointing to the property, in the same order as the
+      labels appear, but with duplicates removed.
+
+      'label_1: label2: x = ...' gives 'labels' the value
+      {"label_1", "label_2"}.
+
+    offset_labels:
+      A dictionary that maps any labels within the property's value to their
+      offset, in bytes. For example, 'x = < 0 label_1: 1 label_2: >' gives
+      'offset_labels' the value {"label_1": 4, "label_2": 8}.
+
+      Iteration order will match the order of the labels on Python versions
+      that preserve dict insertion order.
+
+    node:
+      The Node the property is on.
+    """
+
+    #
+    # Public interface
+    #
+
+    def __init__(self, node: Node, name: str):
+        if "@" in name:
+            node.dt._parse_error("'@' is only allowed in node names")
+
+        self.name = name
+        self.node = node
+        self.value = b""
+        self.labels: List[str] = []
+        self._label_offset_lst: List[Tuple[str, int]] = []
+        # We have to wait to set this until later, when we've got
+        # the entire tree.
+        self.offset_labels: Dict[str, int] = {}
+
+        # A list of [offset, label, type] lists (sorted by offset),
+        # giving the locations of references within the value. 'type'
+        # is either _MarkerType.PATH, for a node path reference,
+        # _MarkerType.PHANDLE, for a phandle reference, or
+        # _MarkerType.LABEL, for a label on/within data. Node paths
+        # and phandles need to be patched in after parsing.
+        self._markers: List[List] = []
+
+    def to_num(self, signed=False) -> int:
+        """
+        Returns the value of the property as a number.
+
+        Raises DTError if the property was not assigned with this syntax (has
+        Property.type Type.NUM):
+
+            foo = < 1 >;
+
+        signed (default: False):
+          If True, the value will be interpreted as signed rather than
+          unsigned.
+        """
+        if self.type is not Type.NUM:
+            _err("expected property '{0}' on {1} in {2} to be assigned with "
+                 "'{0} = < (number) >;', not '{3}'"
+                 .format(self.name, self.node.path, self.node.dt.filename,
+                         self))
+
+        return int.from_bytes(self.value, "big", signed=signed)
+
+    def to_nums(self, signed=False) -> List[int]:
+        """
+        Returns the value of the property as a list of numbers.
+
+        Raises DTError if the property was not assigned with this syntax (has
+        Property.type Type.NUM or Type.NUMS):
+
+            foo = < 1 2 ... >;
+
+        signed (default: False):
+          If True, the values will be interpreted as signed rather than
+          unsigned.
+        """
+        if self.type not in (Type.NUM, Type.NUMS):
+            _err("expected property '{0}' on {1} in {2} to be assigned with "
+                 "'{0} = < (number) (number) ... >;', not '{3}'"
+                 .format(self.name, self.node.path, self.node.dt.filename,
+                         self))
+
+        return [int.from_bytes(self.value[i:i + 4], "big", signed=signed)
+                for i in range(0, len(self.value), 4)]
+
+    def to_bytes(self) -> bytes:
+        """
+        Returns the value of the property as a raw 'bytes', like
+        Property.value, except with added type checking.
+
+        Raises DTError if the property was not assigned with this syntax (has
+        Property.type Type.BYTES):
+
+            foo = [ 01 ... ];
+        """
+        if self.type is not Type.BYTES:
+            _err("expected property '{0}' on {1} in {2} to be assigned with "
+                 "'{0} = [ (byte) (byte) ... ];', not '{3}'"
+                 .format(self.name, self.node.path, self.node.dt.filename,
+                         self))
+
+        return self.value
+
+    def to_string(self) -> str:
+        """
+        Returns the value of the property as a string.
+
+        Raises DTError if the property was not assigned with this syntax (has
+        Property.type Type.STRING):
+
+            foo = "string";
+
+        This function might also raise UnicodeDecodeError if the string is
+        not valid UTF-8.
+        """
+        if self.type is not Type.STRING:
+            _err("expected property '{0}' on {1} in {2} to be assigned with "
+                 "'{0} = \"string\";', not '{3}'"
+                 .format(self.name, self.node.path, self.node.dt.filename,
+                         self))
+
+        try:
+            ret = self.value.decode("utf-8")[:-1]  # Strip null
+        except UnicodeDecodeError:
+            _err("value of property '{}' ({!r}) on {} in {} is not valid UTF-8"
+                 .format(self.name, self.value, self.node.path,
+                         self.node.dt.filename))
+
+        return ret  # The separate 'return' appeases the type checker.
+
+    def to_strings(self) -> List[str]:
+        """
+        Returns the value of the property as a list of strings.
+
+        Raises DTError if the property was not assigned with this syntax (has
+        Property.type Type.STRING or Type.STRINGS):
+
+            foo = "string", "string", ... ;
+
+        Also raises DTError if any of the strings are not valid UTF-8.
+        """
+        if self.type not in (Type.STRING, Type.STRINGS):
+            _err("expected property '{0}' on {1} in {2} to be assigned with "
+                 "'{0} = \"string\", \"string\", ... ;', not '{3}'"
+                 .format(self.name, self.node.path, self.node.dt.filename,
+                         self))
+
+        try:
+            ret = self.value.decode("utf-8").split("\0")[:-1]
+        except UnicodeDecodeError:
+            _err("value of property '{}' ({!r}) on {} in {} is not valid UTF-8"
+                 .format(self.name, self.value, self.node.path,
+                         self.node.dt.filename))
+
+        return ret  # The separate 'return' appeases the type checker.
+
+    def to_node(self) -> Node:
+        """
+        Returns the Node the phandle in the property points to.
+
+        Raises DTError if the property was not assigned with this syntax (has
+        Property.type Type.PHANDLE).
+
+            foo = < &bar >;
+        """
+        if self.type is not Type.PHANDLE:
+            _err("expected property '{0}' on {1} in {2} to be assigned with "
+                 "'{0} = < &foo >;', not '{3}'"
+                 .format(self.name, self.node.path, self.node.dt.filename,
+                         self))
+
+        return self.node.dt.phandle2node[int.from_bytes(self.value, "big")]
+
+    def to_nodes(self) -> List[Node]:
+        """
+        Returns a list with the Nodes the phandles in the property point to.
+
+        Raises DTError if the property value contains anything other than
+        phandles. All of the following are accepted:
+
+            foo = < >
+            foo = < &bar >;
+            foo = < &bar &baz ... >;
+            foo = < &bar ... >, < &baz ... >;
+        """
+        def type_ok():
+            if self.type in (Type.PHANDLE, Type.PHANDLES):
+                return True
+            # Also accept 'foo = < >;'
+            return self.type is Type.NUMS and not self.value
+
+        if not type_ok():
+            _err("expected property '{0}' on {1} in {2} to be assigned with "
+                 "'{0} = < &foo &bar ... >;', not '{3}'"
+                 .format(self.name, self.node.path,
+                         self.node.dt.filename, self))
+
+        return [self.node.dt.phandle2node[int.from_bytes(self.value[i:i + 4],
+                                                         "big")]
+                for i in range(0, len(self.value), 4)]
+
+    def to_path(self) -> Node:
+        """
+        Returns the Node referenced by the path stored in the property.
+
+        Raises DTError if the property was not assigned with either of these
+        syntaxes (has Property.type Type.PATH or Type.STRING):
+
+            foo = &bar;
+            foo = "/bar";
+
+        For the second case, DTError is raised if the path does not exist.
+        """
+        if self.type not in (Type.PATH, Type.STRING):
+            _err("expected property '{0}' on {1} in {2} to be assigned with "
+                 "either '{0} = &foo' or '{0} = \"/path/to/node\"', not '{3}'"
+                 .format(self.name, self.node.path, self.node.dt.filename,
+                         self))
+
+        try:
+            path = self.value.decode("utf-8")[:-1]
+        except UnicodeDecodeError:
+            _err("value of property '{}' ({!r}) on {} in {} is not valid UTF-8"
+                 .format(self.name, self.value, self.node.path,
+                         self.node.dt.filename))
+
+        try:
+            ret = self.node.dt.get_node(path)
+        except DTError:
+            _err("property '{}' on {} in {} points to the non-existent node "
+                 "\"{}\"".format(self.name, self.node.path,
+                                 self.node.dt.filename, path))
+
+        return ret  # The separate 'return' appeases the type checker.
+
+    @property
+    def type(self) -> int:
+        """
+        See the class docstring.
+        """
+        # Data labels (e.g. 'foo = label: <3>') are irrelevant, so filter them
+        # out
+        types = [marker[1] for marker in self._markers
+                 if marker[1] != _MarkerType.LABEL]
+
+        if not types:
+            return Type.EMPTY
+
+        if types == [_MarkerType.UINT8]:
+            return Type.BYTES
+
+        if types == [_MarkerType.UINT32]:
+            return Type.NUM if len(self.value) == 4 else Type.NUMS
+
+        # Treat 'foo = <1 2 3>, <4 5>, ...' as Type.NUMS too
+        if set(types) == {_MarkerType.UINT32}:
+            return Type.NUMS
+
+        if set(types) == {_MarkerType.STRING}:
+            return Type.STRING if len(types) == 1 else Type.STRINGS
+
+        if types == [_MarkerType.PATH]:
+            return Type.PATH
+
+        if types == [_MarkerType.UINT32, _MarkerType.PHANDLE] and \
+                len(self.value) == 4:
+            return Type.PHANDLE
+
+        if set(types) == {_MarkerType.UINT32, _MarkerType.PHANDLE}:
+            if len(self.value) == 4*types.count(_MarkerType.PHANDLE):
+                # Array with just phandles in it
+                return Type.PHANDLES
+            # Array with both phandles and numbers
+            return Type.PHANDLES_AND_NUMS
+
+        return Type.COMPOUND
+
+    def __str__(self):
+        s = "".join(label + ": " for label in self.labels) + self.name
+        if not self.value:
+            return s + ";"
+
+        s += " ="
+
+        for i, (pos, marker_type, ref) in enumerate(self._markers):
+            if i < len(self._markers) - 1:
+                next_marker = self._markers[i + 1]
+            else:
+                next_marker = None
+
+            # End of current marker
+            end = next_marker[0] if next_marker else len(self.value)
+
+            if marker_type is _MarkerType.STRING:
+                # end - 1 to strip off the null terminator
+                s += ' "{}"'.format(_decode_and_escape(
+                    self.value[pos:end - 1]))
+                if end != len(self.value):
+                    s += ","
+            elif marker_type is _MarkerType.PATH:
+                s += " &" + ref
+                if end != len(self.value):
+                    s += ","
+            else:
+                # <> or []
+
+                if marker_type is _MarkerType.LABEL:
+                    s += " {}:".format(ref)
+                elif marker_type is _MarkerType.PHANDLE:
+                    s += " &" + ref
+                    pos += 4
+                    # Subtle: There might be more data between the phandle and
+                    # the next marker, so we can't 'continue' here
+                else:  # marker_type is _MarkerType.UINT*
+                    elm_size = _TYPE_TO_N_BYTES[marker_type]
+                    s += _N_BYTES_TO_START_STR[elm_size]
+
+                while pos != end:
+                    num = int.from_bytes(self.value[pos:pos + elm_size],
+                                         "big")
+                    if elm_size == 1:
+                        s += " {:02X}".format(num)
+                    else:
+                        s += " " + hex(num)
+
+                    pos += elm_size
+
+                if pos != 0 and \
+                   (not next_marker or
+                    next_marker[1] not in (_MarkerType.PHANDLE, _MarkerType.LABEL)):
+
+                    s += _N_BYTES_TO_END_STR[elm_size]
+                    if pos != len(self.value):
+                        s += ","
+
+        return s + ";"
+
+
+    def __repr__(self):
+        return "<Property '{}' at '{}' in '{}'>" \
+               .format(self.name, self.node.path, self.node.dt.filename)
+
+    #
+    # Internal functions
+    #
+
+    def _add_marker(self, marker_type: _MarkerType, data: Any = None):
+        # Helper for registering markers in the value that are processed after
+        # parsing. See _fixup_props(). 'marker_type' identifies the type of
+        # marker, and 'data' has any optional data associated with the marker.
+
+        # len(self.value) gives the current offset. This function is called
+        # while the value is built. We use a list instead of a tuple to be able
+        # to fix up offsets later (they might increase if the value includes
+        # path references, e.g. 'foo = &bar, <3>;', which are expanded later).
+        self._markers.append([len(self.value), marker_type, data])
+
+        # For phandle references, add a dummy value with the same length as a
+        # phandle. This is handy for the length check in _register_phandles().
+        if marker_type is _MarkerType.PHANDLE:
+            self.value += b"\0\0\0\0"
+
+class _T(enum.IntEnum):
+    # Token IDs used by the DT lexer.
+
+    # These values must be contiguous and start from 1.
+    INCLUDE = 1
+    LINE = 2
+    STRING = 3
+    DTS_V1 = 4
+    PLUGIN = 5
+    MEMRESERVE = 6
+    BITS = 7
+    DEL_PROP = 8
+    DEL_NODE = 9
+    OMIT_IF_NO_REF = 10
+    LABEL = 11
+    CHAR_LITERAL = 12
+    REF = 13
+    INCBIN = 14
+    SKIP = 15
+    EOF = 16
+
+    # These values must be larger than the above contiguous range.
+    NUM = 17
+    PROPNODENAME = 18
+    MISC = 19
+    BYTE = 20
+    BAD = 21
+
+class _FileStackElt(NamedTuple):
+    # Used for maintaining the /include/ stack.
+
+    filename: str
+    lineno: int
+    contents: str
+    pos: int
+
+_TokVal = Union[int, str]
+
+class _Token(NamedTuple):
+    id: int
+    val: _TokVal
+
+class DT:
+    """
+    Represents a devicetree parsed from a .dts file (or from many files, if the
+    .dts file /include/s other files). Creating many instances of this class is
+    fine. The library has no global state.
+
+    These attributes are available on DT instances:
+
+    root:
+      A Node instance representing the root (/) node.
+
+    alias2node:
+      A dictionary that maps maps alias strings (from /aliases) to Node
+      instances
+
+    label2node:
+      A dictionary that maps each node label (a string) to the Node instance
+      for the node.
+
+    label2prop:
+      A dictionary that maps each property label (a string) to a Property
+      instance.
+
+    label2prop_offset:
+      A dictionary that maps each label (a string) within a property value
+      (e.g., 'x = label_1: < 1 label2: 2 >;') to a (prop, offset) tuple, where
+      'prop' is a Property instance and 'offset' the byte offset (0 for label_1
+      and 4 for label_2 in the example).
+
+    phandle2node:
+      A dictionary that maps each phandle (a number) to a Node instance.
+
+    memreserves:
+      A list of (labels, address, length) tuples for the /memreserve/s in the
+      .dts file, in the same order as they appear in the file.
+
+      'labels' is a possibly empty set with all labels preceding the memreserve
+      (e.g., 'label1: label2: /memreserve/ ...'). 'address' and 'length' are
+      numbers.
+
+    filename:
+      The filename passed to the DT constructor.
+    """
+
+    #
+    # Public interface
+    #
+
+    def __init__(self, filename: str, include_path: Iterable[str] = (),
+                 force: bool = False):
+        """
+        Parses a DTS file to create a DT instance. Raises OSError if 'filename'
+        can't be opened, and DTError for any parse errors.
+
+        filename:
+          Path to the .dts file to parse.
+
+        include_path:
+          An iterable (e.g. list or tuple) containing paths to search for
+          /include/d and /incbin/'d files. By default, files are only looked up
+          relative to the .dts file that contains the /include/ or /incbin/.
+
+        force:
+          Try not to raise DTError even if the input tree has errors.
+          For experimental use; results not guaranteed.
+        """
+        self.filename = filename
+        self._include_path = list(include_path)
+        self._force = force
+
+        with open(filename, encoding="utf-8") as f:
+            self._file_contents = f.read()
+
+        self._tok_i = self._tok_end_i = 0
+        self._filestack: List[_FileStackElt] = []
+
+        self.alias2node: Dict[str, Node] = {}
+
+        self._lexer_state: int = _DEFAULT
+        self._saved_token: Optional[_Token] = None
+
+        self._lineno: int = 1
+
+        self._root: Optional[Node] = None
+
+        self._parse_dt()
+
+        self._register_phandles()
+        self._fixup_props()
+        self._register_aliases()
+        self._remove_unreferenced()
+        self._register_labels()
+
+    @property
+    def root(self) -> Node:
+        """
+        See the class documentation.
+        """
+        # This is necessary because mypy can't tell that we never
+        # treat self._root as a non-None value until it's initialized
+        # properly in _parse_dt().
+        return self._root       # type: ignore
+
+    def get_node(self, path: str) -> Node:
+        """
+        Returns the Node instance for the node with path or alias 'path' (a
+        string). Raises DTError if the path or alias doesn't exist.
+
+        For example, both dt.get_node("/foo/bar") and dt.get_node("bar-alias")
+        will return the 'bar' node below:
+
+          /dts-v1/;
+
+          / {
+                  foo {
+                          bar_label: bar {
+                                  baz {
+                                  };
+                          };
+                  };
+
+                  aliases {
+                          bar-alias = &bar-label;
+                  };
+          };
+
+        Fetching subnodes via aliases is supported:
+        dt.get_node("bar-alias/baz") returns the 'baz' node.
+        """
+        if path.startswith("/"):
+            return _root_and_path_to_node(self.root, path, path)
+
+        # Path does not start with '/'. First component must be an alias.
+        alias, _, rest = path.partition("/")
+        if alias not in self.alias2node:
+            _err("no alias '{}' found -- did you forget the leading '/' in "
+                 "the node path?".format(alias))
+
+        return _root_and_path_to_node(self.alias2node[alias], rest, path)
+
+    def has_node(self, path: str) -> bool:
+        """
+        Returns True if the path or alias 'path' exists. See Node.get_node().
+        """
+        try:
+            self.get_node(path)
+            return True
+        except DTError:
+            return False
+
+    def node_iter(self) -> Iterable[Node]:
+        """
+        Returns a generator for iterating over all nodes in the devicetree.
+
+        For example, this will print the name of each node that has a property
+        called 'foo':
+
+          for node in dt.node_iter():
+              if "foo" in node.props:
+                  print(node.name)
+        """
+        yield from self.root.node_iter()
+
+    def __str__(self):
+        """
+        Returns a DTS representation of the devicetree. Called automatically if
+        the DT instance is print()ed.
+        """
+        s = "/dts-v1/;\n\n"
+
+        if self.memreserves:
+            for labels, address, offset in self.memreserves:
+                # List the labels in a consistent order to help with testing
+                for label in labels:
+                    s += label + ": "
+                s += "/memreserve/ {:#018x} {:#018x};\n" \
+                     .format(address, offset)
+            s += "\n"
+
+        return s + str(self.root)
+
+    def __repr__(self):
+        """
+        Returns some information about the DT instance. Called automatically if
+        the DT instance is evaluated.
+        """
+        return "DT(filename='{}', include_path={})" \
+               .format(self.filename, self._include_path)
+
+    #
+    # Parsing
+    #
+
+    def _parse_dt(self):
+        # Top-level parsing loop
+
+        self._parse_header()
+        self._parse_memreserves()
+
+        while True:
+            tok = self._next_token()
+
+            if tok.val == "/":
+                # '/ { ... };', the root node
+                if not self._root:
+                    self._root = Node(name="/", parent=None, dt=self)
+                self._parse_node(self.root)
+
+            elif tok.id in (_T.LABEL, _T.REF):
+                # '&foo { ... };' or 'label: &foo { ... };'. The C tools only
+                # support a single label here too.
+
+                if tok.id == _T.LABEL:
+                    label = tok.val
+                    tok = self._next_token()
+                    if tok.id != _T.REF:
+                        self._parse_error("expected label reference (&foo)")
+                else:
+                    label = None
+
+                try:
+                    node = self._ref2node(tok.val)
+                except DTError as e:
+                    self._parse_error(e)
+                node = self._parse_node(node)
+
+                if label:
+                    _append_no_dup(node.labels, label)
+
+            elif tok.id == _T.DEL_NODE:
+                self._next_ref2node()._del()
+                self._expect_token(";")
+
+            elif tok.id == _T.OMIT_IF_NO_REF:
+                self._next_ref2node()._omit_if_no_ref = True
+                self._expect_token(";")
+
+            elif tok.id == _T.EOF:
+                if not self._root:
+                    self._parse_error("no root node defined")
+                return
+
+            else:
+                self._parse_error("expected '/' or label reference (&foo)")
+
+    def _parse_header(self):
+        # Parses /dts-v1/ (expected) and /plugin/ (unsupported) at the start of
+        # files. There may be multiple /dts-v1/ at the start of a file.
+
+        has_dts_v1 = False
+
+        while self._peek_token().id == _T.DTS_V1:
+            has_dts_v1 = True
+            self._next_token()
+            self._expect_token(";")
+            # /plugin/ always comes after /dts-v1/
+            if self._peek_token().id == _T.PLUGIN:
+                self._parse_error("/plugin/ is not supported")
+
+        if not has_dts_v1:
+            self._parse_error("expected '/dts-v1/;' at start of file")
+
+    def _parse_memreserves(self):
+        # Parses /memreserve/, which appears after /dts-v1/
+
+        self.memreserves = []
+        while True:
+            # Labels before /memreserve/
+            labels = []
+            while self._peek_token().id == _T.LABEL:
+                _append_no_dup(labels, self._next_token().val)
+
+            if self._peek_token().id == _T.MEMRESERVE:
+                self._next_token()
+                self.memreserves.append(
+                    (labels, self._eval_prim(), self._eval_prim()))
+                self._expect_token(";")
+            elif labels:
+                self._parse_error("expected /memreserve/ after labels at "
+                                  "beginning of file")
+            else:
+                return
+
+    def _parse_node(self, node):
+        # Parses the '{ ... };' part of 'node-name { ... };'. Returns the new
+        # Node.
+
+        self._expect_token("{")
+        while True:
+            labels, omit_if_no_ref = self._parse_propnode_labels()
+            tok = self._next_token()
+
+            if tok.id == _T.PROPNODENAME:
+                if self._peek_token().val == "{":
+                    # '<tok> { ...', expect node
+
+                    if tok.val.count("@") > 1:
+                        self._parse_error("multiple '@' in node name")
+
+                    # Fetch the existing node if it already exists. This
+                    # happens when overriding nodes.
+                    child = node.nodes.get(tok.val) or \
+                        Node(name=tok.val, parent=node, dt=self)
+
+                    for label in labels:
+                        _append_no_dup(child.labels, label)
+
+                    if omit_if_no_ref:
+                        child._omit_if_no_ref = True
+
+                    node.nodes[child.name] = child
+                    self._parse_node(child)
+
+                else:
+                    # Not '<tok> { ...', expect property assignment
+
+                    if omit_if_no_ref:
+                        self._parse_error(
+                            "/omit-if-no-ref/ can only be used on nodes")
+
+                    prop = node._get_prop(tok.val)
+
+                    if self._check_token("="):
+                        self._parse_assignment(prop)
+                    elif not self._check_token(";"):
+                        # ';' is for an empty property, like 'foo;'
+                        self._parse_error("expected '{', '=', or ';'")
+
+                    for label in labels:
+                        _append_no_dup(prop.labels, label)
+
+            elif tok.id == _T.DEL_NODE:
+                tok2 = self._next_token()
+                if tok2.id != _T.PROPNODENAME:
+                    self._parse_error("expected node name")
+                if tok2.val in node.nodes:
+                    node.nodes[tok2.val]._del()
+                self._expect_token(";")
+
+            elif tok.id == _T.DEL_PROP:
+                tok2 = self._next_token()
+                if tok2.id != _T.PROPNODENAME:
+                    self._parse_error("expected property name")
+                node.props.pop(tok2.val, None)
+                self._expect_token(";")
+
+            elif tok.val == "}":
+                self._expect_token(";")
+                return node
+
+            else:
+                self._parse_error("expected node name, property name, or '}'")
+
+    def _parse_propnode_labels(self):
+        # _parse_node() helpers for parsing labels and /omit-if-no-ref/s before
+        # nodes and properties. Returns a (<label list>, <omit-if-no-ref bool>)
+        # tuple.
+
+        labels = []
+        omit_if_no_ref = False
+        while True:
+            tok = self._peek_token()
+            if tok.id == _T.LABEL:
+                _append_no_dup(labels, tok.val)
+            elif tok.id == _T.OMIT_IF_NO_REF:
+                omit_if_no_ref = True
+            elif (labels or omit_if_no_ref) and tok.id != _T.PROPNODENAME:
+                # Got something like 'foo: bar: }'
+                self._parse_error("expected node or property name")
+            else:
+                return labels, omit_if_no_ref
+
+            self._next_token()
+
+    def _parse_assignment(self, prop):
+        # Parses the right-hand side of property assignment
+        #
+        # prop:
+        #   'Property' instance being assigned
+
+        # Remove any old value, path/phandle references, and in-value labels,
+        # in case the property value is being overridden
+        prop.value = b""
+        prop._markers = []
+
+        while True:
+            # Parse labels before the value (e.g., '..., label: < 0 >')
+            self._parse_value_labels(prop)
+
+            tok = self._next_token()
+
+            if tok.val == "<":
+                self._parse_cells(prop, 4)
+
+            elif tok.id == _T.BITS:
+                n_bits = self._expect_num()
+                if n_bits not in {8, 16, 32, 64}:
+                    self._parse_error("expected 8, 16, 32, or 64")
+                self._expect_token("<")
+                self._parse_cells(prop, n_bits//8)
+
+            elif tok.val == "[":
+                self._parse_bytes(prop)
+
+            elif tok.id == _T.STRING:
+                prop._add_marker(_MarkerType.STRING)
+                prop.value += self._unescape(tok.val.encode("utf-8")) + b"\0"
+
+            elif tok.id == _T.REF:
+                prop._add_marker(_MarkerType.PATH, tok.val)
+
+            elif tok.id == _T.INCBIN:
+                self._parse_incbin(prop)
+
+            else:
+                self._parse_error("malformed value")
+
+            # Parse labels after the value (e.g., '< 0 > label:, ...')
+            self._parse_value_labels(prop)
+
+            tok = self._next_token()
+            if tok.val == ";":
+                return
+            if tok.val == ",":
+                continue
+            self._parse_error("expected ';' or ','")
+
+    def _parse_cells(self, prop, n_bytes):
+        # Parses '<...>'
+
+        prop._add_marker(_N_BYTES_TO_TYPE[n_bytes])
+
+        while True:
+            tok = self._peek_token()
+            if tok.id == _T.REF:
+                self._next_token()
+                if n_bytes != 4:
+                    self._parse_error("phandle references are only allowed in "
+                                      "arrays with 32-bit elements")
+                prop._add_marker(_MarkerType.PHANDLE, tok.val)
+
+            elif tok.id == _T.LABEL:
+                prop._add_marker(_MarkerType.LABEL, tok.val)
+                self._next_token()
+
+            elif self._check_token(">"):
+                return
+
+            else:
+                # Literal value
+                num = self._eval_prim()
+                try:
+                    prop.value += num.to_bytes(n_bytes, "big")
+                except OverflowError:
+                    try:
+                        # Try again as a signed number, in case it's negative
+                        prop.value += num.to_bytes(n_bytes, "big", signed=True)
+                    except OverflowError:
+                        self._parse_error("{} does not fit in {} bits"
+                                          .format(num, 8*n_bytes))
+
+    def _parse_bytes(self, prop):
+        # Parses '[ ... ]'
+
+        prop._add_marker(_MarkerType.UINT8)
+
+        while True:
+            tok = self._next_token()
+            if tok.id == _T.BYTE:
+                prop.value += tok.val.to_bytes(1, "big")
+
+            elif tok.id == _T.LABEL:
+                prop._add_marker(_MarkerType.LABEL, tok.val)
+
+            elif tok.val == "]":
+                return
+
+            else:
+                self._parse_error("expected two-digit byte or ']'")
+
+    def _parse_incbin(self, prop):
+        # Parses
+        #
+        #   /incbin/ ("filename")
+        #
+        # and
+        #
+        #   /incbin/ ("filename", <offset>, <size>)
+
+        prop._add_marker(_MarkerType.UINT8)
+
+        self._expect_token("(")
+
+        tok = self._next_token()
+        if tok.id != _T.STRING:
+            self._parse_error("expected quoted filename")
+        filename = tok.val
+
+        tok = self._next_token()
+        if tok.val == ",":
+            offset = self._eval_prim()
+            self._expect_token(",")
+            size = self._eval_prim()
+            self._expect_token(")")
+        else:
+            if tok.val != ")":
+                self._parse_error("expected ',' or ')'")
+            offset = None
+
+        try:
+            with self._open(filename, "rb") as f:
+                if offset is None:
+                    prop.value += f.read()
+                else:
+                    f.seek(offset)
+                    prop.value += f.read(size)
+        except OSError as e:
+            self._parse_error("could not read '{}': {}"
+                              .format(filename, e))
+
+    def _parse_value_labels(self, prop):
+        # _parse_assignment() helper for parsing labels before/after each
+        # comma-separated value
+
+        while True:
+            tok = self._peek_token()
+            if tok.id != _T.LABEL:
+                return
+            prop._add_marker(_MarkerType.LABEL, tok.val)
+            self._next_token()
+
+    def _node_phandle(self, node):
+        # Returns the phandle for Node 'node', creating a new phandle if the
+        # node has no phandle, and fixing up the value for existing
+        # self-referential phandles (which get set to b'\0\0\0\0' initially).
+        # Self-referential phandles must be rewritten instead of recreated, so
+        # that labels are preserved.
+
+        if "phandle" in node.props:
+            phandle_prop = node.props["phandle"]
+        else:
+            phandle_prop = Property(node, "phandle")
+            phandle_prop._add_marker(_MarkerType.UINT32)  # For displaying
+            phandle_prop.value = b'\0\0\0\0'
+
+        if phandle_prop.value == b'\0\0\0\0':
+            phandle_i = 1
+            while phandle_i in self.phandle2node:
+                phandle_i += 1
+            self.phandle2node[phandle_i] = node
+
+            phandle_prop.value = phandle_i.to_bytes(4, "big")
+            node.props["phandle"] = phandle_prop
+
+        return phandle_prop.value
+
+    # Expression evaluation
+
+    def _eval_prim(self):
+        tok = self._peek_token()
+        if tok.id in (_T.NUM, _T.CHAR_LITERAL):
+            return self._next_token().val
+
+        tok = self._next_token()
+        if tok.val != "(":
+            self._parse_error("expected number or parenthesized expression")
+        val = self._eval_ternary()
+        self._expect_token(")")
+        return val
+
+    def _eval_ternary(self):
+        val = self._eval_or()
+        if self._check_token("?"):
+            if_val = self._eval_ternary()
+            self._expect_token(":")
+            else_val = self._eval_ternary()
+            return if_val if val else else_val
+        return val
+
+    def _eval_or(self):
+        val = self._eval_and()
+        while self._check_token("||"):
+            val = 1 if self._eval_and() or val else 0
+        return val
+
+    def _eval_and(self):
+        val = self._eval_bitor()
+        while self._check_token("&&"):
+            val = 1 if self._eval_bitor() and val else 0
+        return val
+
+    def _eval_bitor(self):
+        val = self._eval_bitxor()
+        while self._check_token("|"):
+            val |= self._eval_bitxor()
+        return val
+
+    def _eval_bitxor(self):
+        val = self._eval_bitand()
+        while self._check_token("^"):
+            val ^= self._eval_bitand()
+        return val
+
+    def _eval_bitand(self):
+        val = self._eval_eq()
+        while self._check_token("&"):
+            val &= self._eval_eq()
+        return val
+
+    def _eval_eq(self):
+        val = self._eval_rela()
+        while True:
+            if self._check_token("=="):
+                val = 1 if val == self._eval_rela() else 0
+            elif self._check_token("!="):
+                val = 1 if val != self._eval_rela() else 0
+            else:
+                return val
+
+    def _eval_rela(self):
+        val = self._eval_shift()
+        while True:
+            if self._check_token("<"):
+                val = 1 if val < self._eval_shift() else 0
+            elif self._check_token(">"):
+                val = 1 if val > self._eval_shift() else 0
+            elif self._check_token("<="):
+                val = 1 if val <= self._eval_shift() else 0
+            elif self._check_token(">="):
+                val = 1 if val >= self._eval_shift() else 0
+            else:
+                return val
+
+    def _eval_shift(self):
+        val = self._eval_add()
+        while True:
+            if self._check_token("<<"):
+                val <<= self._eval_add()
+            elif self._check_token(">>"):
+                val >>= self._eval_add()
+            else:
+                return val
+
+    def _eval_add(self):
+        val = self._eval_mul()
+        while True:
+            if self._check_token("+"):
+                val += self._eval_mul()
+            elif self._check_token("-"):
+                val -= self._eval_mul()
+            else:
+                return val
+
+    def _eval_mul(self):
+        val = self._eval_unary()
+        while True:
+            if self._check_token("*"):
+                val *= self._eval_unary()
+            elif self._check_token("/"):
+                denom = self._eval_unary()
+                if not denom:
+                    self._parse_error("division by zero")
+                val //= denom
+            elif self._check_token("%"):
+                denom = self._eval_unary()
+                if not denom:
+                    self._parse_error("division by zero")
+                val %= denom
+            else:
+                return val
+
+    def _eval_unary(self):
+        if self._check_token("-"):
+            return -self._eval_unary()
+        if self._check_token("~"):
+            return ~self._eval_unary()
+        if self._check_token("!"):
+            return 0 if self._eval_unary() else 1
+        return self._eval_prim()
+
+    #
+    # Lexing
+    #
+
+    def _check_token(self, val):
+        if self._peek_token().val == val:
+            self._next_token()
+            return True
+        return False
+
+    def _peek_token(self):
+        if not self._saved_token:
+            self._saved_token = self._next_token()
+        return self._saved_token
+
+    def _next_token(self):
+        if self._saved_token:
+            tmp = self._saved_token
+            self._saved_token = None
+            return tmp
+
+        while True:
+            tok_id = None
+
+            match = _token_re.match(self._file_contents, self._tok_end_i)
+            if match:
+                tok_id = match.lastindex
+                if tok_id == _T.CHAR_LITERAL:
+                    val = self._unescape(match.group(tok_id).encode("utf-8"))
+                    if len(val) != 1:
+                        self._parse_error("character literals must be length 1")
+                    tok_val = ord(val)
+                else:
+                    tok_val = match.group(tok_id)
+
+            elif self._lexer_state is _DEFAULT:
+                match = _num_re.match(self._file_contents, self._tok_end_i)
+                if match:
+                    tok_id = _T.NUM
+                    num_s = match.group(1)
+                    tok_val = int(num_s,
+                                  16 if num_s.startswith(("0x", "0X")) else
+                                  8 if num_s[0] == "0" else
+                                  10)
+
+            elif self._lexer_state is _EXPECT_PROPNODENAME:
+                match = _propnodename_re.match(self._file_contents,
+                                               self._tok_end_i)
+                if match:
+                    tok_id = _T.PROPNODENAME
+                    tok_val = match.group(1)
+                    self._lexer_state = _DEFAULT
+
+            else:  # self._lexer_state is _EXPECT_BYTE
+                match = _byte_re.match(self._file_contents, self._tok_end_i)
+                if match:
+                    tok_id = _T.BYTE
+                    tok_val = int(match.group(), 16)
+
+            if not tok_id:
+                match = _misc_re.match(self._file_contents, self._tok_end_i)
+                if match:
+                    tok_id = _T.MISC
+                    tok_val = match.group()
+                else:
+                    self._tok_i = self._tok_end_i
+                    # Could get here due to a node/property naming appearing in
+                    # an unexpected context as well as for bad characters in
+                    # files. Generate a token for it so that the error can
+                    # trickle up to some context where we can give a more
+                    # helpful error message.
+                    return _Token(_T.BAD, "<unknown token>")
+
+            self._tok_i = match.start()
+            self._tok_end_i = match.end()
+
+            if tok_id == _T.SKIP:
+                self._lineno += tok_val.count("\n")
+                continue
+
+            # /include/ is handled in the lexer in the C tools as well, and can
+            # appear anywhere
+            if tok_id == _T.INCLUDE:
+                # Can have newlines between /include/ and the filename
+                self._lineno += tok_val.count("\n")
+                # Do this manual extraction instead of doing it in the regex so
+                # that we can properly count newlines
+                filename = tok_val[tok_val.find('"') + 1:-1]
+                self._enter_file(filename)
+                continue
+
+            if tok_id == _T.LINE:
+                # #line directive
+                self._lineno = int(tok_val.split()[0]) - 1
+                self.filename = tok_val[tok_val.find('"') + 1:-1]
+                continue
+
+            if tok_id == _T.EOF:
+                if self._filestack:
+                    self._leave_file()
+                    continue
+                return _Token(_T.EOF, "<EOF>")
+
+            # State handling
+
+            if tok_id in (_T.DEL_PROP, _T.DEL_NODE, _T.OMIT_IF_NO_REF) or \
+               tok_val in ("{", ";"):
+
+                self._lexer_state = _EXPECT_PROPNODENAME
+
+            elif tok_val == "[":
+                self._lexer_state = _EXPECT_BYTE
+
+            elif tok_id in (_T.MEMRESERVE, _T.BITS) or tok_val == "]":
+                self._lexer_state = _DEFAULT
+
+            return _Token(tok_id, tok_val)
+
+    def _expect_token(self, tok_val):
+        # Raises an error if the next token does not have the string value
+        # 'tok_val'. Returns the token.
+
+        tok = self._next_token()
+        if tok.val != tok_val:
+            self._parse_error("expected '{}', not '{}'"
+                              .format(tok_val, tok.val))
+
+        return tok
+
+    def _expect_num(self):
+        # Raises an error if the next token is not a number. Returns the token.
+
+        tok = self._next_token()
+        if tok.id != _T.NUM:
+            self._parse_error("expected number")
+        return tok.val
+
+    def _parse_error(self, s):
+        _err("{}:{} (column {}): parse error: {}".format(
+            self.filename, self._lineno,
+            # This works out for the first line of the file too, where rfind()
+            # returns -1
+            self._tok_i - self._file_contents.rfind("\n", 0, self._tok_i + 1),
+            s))
+
+    def _enter_file(self, filename):
+        # Enters the /include/d file 'filename', remembering the position in
+        # the /include/ing file for later
+
+        self._filestack.append(
+            _FileStackElt(self.filename, self._lineno,
+                          self._file_contents, self._tok_end_i))
+
+        # Handle escapes in filenames, just for completeness
+        filename = self._unescape(filename.encode("utf-8"))
+        try:
+            filename = filename.decode("utf-8")
+        except UnicodeDecodeError:
+            self._parse_error("filename is not valid UTF-8")
+
+        with self._open(filename, encoding="utf-8") as f:
+            try:
+                self._file_contents = f.read()
+            except OSError as e:
+                self._parse_error(e)
+
+        # Check for recursive /include/
+        for i, parent in enumerate(self._filestack):
+            if filename == parent[0]:
+                self._parse_error("recursive /include/:\n" + " ->\n".join(
+                    ["{}:{}".format(parent[0], parent[1])
+                        for parent in self._filestack[i:]] +
+                    [filename]))
+
+        self.filename = f.name
+        self._lineno = 1
+        self._tok_end_i = 0
+
+    def _leave_file(self):
+        # Leaves an /include/d file, returning to the file that /include/d it
+
+        self.filename, self._lineno, self._file_contents, self._tok_end_i = \
+            self._filestack.pop()
+
+    def _next_ref2node(self):
+        # Checks that the next token is a label/path reference and returns the
+        # Node it points to. Only used during parsing, so uses _parse_error()
+        # on errors to save some code in callers.
+
+        label = self._next_token()
+        if label.id != _T.REF:
+            self._parse_error(
+                "expected label (&foo) or path (&{/foo/bar}) reference")
+        try:
+            return self._ref2node(label.val)
+        except DTError as e:
+            self._parse_error(e)
+
+    def _ref2node(self, s):
+        # Returns the Node the label/path reference 's' points to
+
+        if s[0] == "{":
+            # Path reference (&{/foo/bar})
+            path = s[1:-1]
+            if not path.startswith("/"):
+                _err("node path '{}' does not start with '/'".format(path))
+            # Will raise DTError if the path doesn't exist
+            return _root_and_path_to_node(self.root, path, path)
+
+        # Label reference (&foo).
+
+        # label2node hasn't been filled in yet, and using it would get messy
+        # when nodes are deleted
+        for node in self.node_iter():
+            if s in node.labels:
+                return node
+
+        _err("undefined node label '{}'".format(s))
+
+    #
+    # Post-processing
+    #
+
+    def _register_phandles(self):
+        # Registers any manually-inserted phandle properties in
+        # self.phandle2node, so that we can avoid allocating any phandles from
+        # that set. Also checks the format of the phandles and does misc.
+        # sanity checking.
+
+        self.phandle2node = {}
+        for node in self.node_iter():
+            phandle = node.props.get("phandle")
+            if phandle:
+                if len(phandle.value) != 4:
+                    _err("{}: bad phandle length ({}), expected 4 bytes"
+                         .format(node.path, len(phandle.value)))
+
+                is_self_referential = False
+                for marker in phandle._markers:
+                    _, marker_type, ref = marker
+                    if marker_type is _MarkerType.PHANDLE:
+                        # The phandle's value is itself a phandle reference
+                        if self._ref2node(ref) is node:
+                            # Alright to set a node's phandle equal to its own
+                            # phandle. It'll force a new phandle to be
+                            # allocated even if the node is otherwise
+                            # unreferenced.
+                            is_self_referential = True
+                            break
+
+                        _err("{}: {} refers to another node"
+                             .format(node.path, phandle.name))
+
+                # Could put on else on the 'for' above too, but keep it
+                # somewhat readable
+                if not is_self_referential:
+                    phandle_val = int.from_bytes(phandle.value, "big")
+
+                    if phandle_val in {0, 0xFFFFFFFF}:
+                        _err("{}: bad value {:#010x} for {}"
+                             .format(node.path, phandle_val, phandle.name))
+
+                    if phandle_val in self.phandle2node:
+                        _err("{}: duplicated phandle {:#x} (seen before at {})"
+                             .format(node.path, phandle_val,
+                                     self.phandle2node[phandle_val].path))
+
+                    self.phandle2node[phandle_val] = node
+
+    def _fixup_props(self):
+        # Fills in node path and phandle references in property values, and
+        # registers labels within values. This must be done after parsing,
+        # since forwards references are allowed and nodes and properties might
+        # be deleted.
+
+        for node in self.node_iter():
+            # The tuple() avoids a 'dictionary changed size during iteration'
+            # error
+            for prop in tuple(node.props.values()):
+                # 'prev_pos' and 'pos' are indices in the unpatched
+                # property value. The result is built up in 'res'.
+                prev_pos = 0
+                res = b""
+
+                for marker in prop._markers:
+                    pos, marker_type, ref = marker
+
+                    # Add data before the marker, reading from the unpatched
+                    # property value
+                    res += prop.value[prev_pos:pos]
+
+                    # Fix the marker offset so that it's correct for the
+                    # patched property value, for later (not used in this
+                    # function). The offset might change due to path
+                    # references, which expand to something like "/foo/bar".
+                    marker[0] = len(res)
+
+                    if marker_type is _MarkerType.LABEL:
+                        # This is a temporary format so that we can catch
+                        # duplicate references. prop._label_offset_lst is changed
+                        # to a dictionary that maps labels to offsets in
+                        # _register_labels().
+                        _append_no_dup(prop._label_offset_lst, (ref, len(res)))
+                    elif marker_type in (_MarkerType.PATH, _MarkerType.PHANDLE):
+                        # Path or phandle reference
+                        try:
+                            ref_node = self._ref2node(ref)
+                        except DTError as e:
+                            _err("{}: {}".format(prop.node.path, e))
+
+                        # For /omit-if-no-ref/
+                        ref_node._is_referenced = True
+
+                        if marker_type is _MarkerType.PATH:
+                            res += ref_node.path.encode("utf-8") + b'\0'
+                        else:  # marker_type is PHANDLE
+                            res += self._node_phandle(ref_node)
+                            # Skip over the dummy phandle placeholder
+                            pos += 4
+
+                    prev_pos = pos
+
+                # Store the final fixed-up value. Add the data after the last
+                # marker.
+                prop.value = res + prop.value[prev_pos:]
+
+    def _register_aliases(self):
+        # Registers aliases from the /aliases node in self.alias2node. Also
+        # checks the format of the alias properties.
+
+        # We copy this to self.alias2node at the end to avoid get_node()
+        # looking up paths via other aliases while verifying aliases
+        alias2node = {}
+
+        alias_re = re.compile("[0-9a-z-]+$")
+
+        aliases = self.root.nodes.get("aliases")
+        if aliases:
+            for prop in aliases.props.values():
+                if not alias_re.match(prop.name):
+                    _err("/aliases: alias property name '{}' should include "
+                         "only characters from [0-9a-z-]".format(prop.name))
+
+                # Property.to_path() checks that the node exists, has
+                # the right type, etc. Swallow errors for invalid
+                # aliases with self._force.
+                try:
+                    alias2node[prop.name] = prop.to_path()
+                except DTError:
+                    if self._force:
+                        continue
+                    raise
+
+        self.alias2node = alias2node
+
+    def _remove_unreferenced(self):
+        # Removes any unreferenced nodes marked with /omit-if-no-ref/ from the
+        # tree
+
+        # tuple() is to avoid 'RuntimeError: dictionary changed size during
+        # iteration' errors
+        for node in tuple(self.node_iter()):
+            if node._omit_if_no_ref and not node._is_referenced:
+                node._del()
+
+    def _register_labels(self):
+        # Checks for duplicate labels and registers labels in label2node,
+        # label2prop, and label2prop_offset
+
+        label2things = collections.defaultdict(set)
+
+        self.label2node = {}
+        self.label2prop = {}
+        self.label2prop_offset = {}
+
+        # Register all labels and the nodes/props they point to in label2things
+        for node in self.node_iter():
+            for label in node.labels:
+                label2things[label].add(node)
+                self.label2node[label] = node
+
+            for prop in node.props.values():
+                for label in prop.labels:
+                    label2things[label].add(prop)
+                    self.label2prop[label] = prop
+
+                for label, offset in prop._label_offset_lst:
+                    label2things[label].add((prop, offset))
+                    self.label2prop_offset[label] = (prop, offset)
+
+                # See _fixup_props()
+                prop.offset_labels = dict(prop._label_offset_lst)
+
+        for label, things in label2things.items():
+            if len(things) > 1:
+                strings = []
+                for thing in things:
+                    if isinstance(thing, Node):
+                        strings.append("on " + thing.path)
+                    elif isinstance(thing, Property):
+                        strings.append("on property '{}' of node {}"
+                                       .format(thing.name, thing.node.path))
+                    else:
+                        # Label within property value
+                        strings.append("in the value of property '{}' of node {}"
+                                       .format(thing[0].name,
+                                               thing[0].node.path))
+
+                # Give consistent error messages to help with testing
+                strings.sort()
+
+                _err("Label '{}' appears ".format(label) +
+                     " and ".join(strings))
+
+
+    #
+    # Misc.
+    #
+
+    def _unescape(self, b):
+        # Replaces backslash escapes in the 'bytes' array 'b'. We can't do this at
+        # the string level, because the result might not be valid UTF-8 when
+        # octal/hex escapes are involved.
+
+        def sub(match):
+            esc = match.group(1)
+            if esc == b"a": return b"\a"
+            if esc == b"b": return b"\b"
+            if esc == b"t": return b"\t"
+            if esc == b"n": return b"\n"
+            if esc == b"v": return b"\v"
+            if esc == b"f": return b"\f"
+            if esc == b"r": return b"\r"
+
+            if esc[0] in b"01234567":
+                # Octal escape
+                try:
+                    return int(esc, 8).to_bytes(1, "big")
+                except OverflowError:
+                    self._parse_error("octal escape out of range (> 255)")
+
+            if esc[0] == ord("x") and len(esc) > 1:
+                # Hex escape
+                return int(esc[1:], 16).to_bytes(1, "big")
+
+            # Return <char> as-is for other \<char>
+            return esc[0].to_bytes(1, "big")
+
+        return _unescape_re.sub(sub, b)
+
+    def _open(self, filename, mode="r", **kwargs):
+        # Wrapper around standard Python open(), accepting the same params.
+        # But searches for a 'filename' file in the directory of the current
+        # file and the include path.
+
+        # The C tools support specifying stdin with '-' too
+        if filename == "-":
+            return sys.stdin.buffer if "b" in mode else sys.stdin
+
+        # Try the directory of the current file first
+        dirname = os.path.dirname(self.filename)
+        try:
+            return open(os.path.join(dirname, filename), mode, **kwargs)
+        except OSError as e:
+            if e.errno != errno.ENOENT:
+                self._parse_error(e)
+
+            # Try each directory from the include path
+            for path in self._include_path:
+                try:
+                    return open(os.path.join(path, filename), mode, **kwargs)
+                except OSError as e:
+                    if e.errno != errno.ENOENT:
+                        self._parse_error(e)
+                    continue
+
+            self._parse_error("'{}' could not be found".format(filename))
+
+#
+# Public functions
+#
+
+def to_num(data: bytes, length: Optional[int] = None,
+           signed: bool = False) -> int:
+    """
+    Converts the 'bytes' array 'data' to a number. The value is expected to be
+    in big-endian format, which is standard in devicetree.
+
+    length (default: None):
+      The expected length of the value in bytes, as a simple type check. If
+      None, the length check is skipped.
+
+    signed (default: False):
+      If True, the value will be interpreted as signed rather than unsigned.
+    """
+    _check_is_bytes(data)
+    if length is not None:
+        _check_length_positive(length)
+        if len(data) != length:
+            _err("{!r} is {} bytes long, expected {}"
+                 .format(data, len(data), length))
+
+    return int.from_bytes(data, "big", signed=signed)
+
+def to_nums(data: bytes, length: int = 4, signed: bool = False) -> List[int]:
+    """
+    Like Property.to_nums(), but takes an arbitrary 'bytes' array. The values
+    are assumed to be in big-endian format, which is standard in devicetree.
+    """
+    _check_is_bytes(data)
+    _check_length_positive(length)
+
+    if len(data) % length:
+        _err("{!r} is {} bytes long, expected a length that's a a multiple of {}"
+             .format(data, len(data), length))
+
+    return [int.from_bytes(data[i:i + length], "big", signed=signed)
+            for i in range(0, len(data), length)]
+
+#
+# Public constants
+#
+
+def _check_is_bytes(data):
+    if not isinstance(data, bytes):
+        _err("'{}' has type '{}', expected 'bytes'"
+             .format(data, type(data).__name__))
+
+def _check_length_positive(length):
+    if length < 1:
+        _err("'length' must be greater than zero, was " + str(length))
+
+def _append_no_dup(lst, elm):
+    # Appends 'elm' to 'lst', but only if it isn't already in 'lst'. Lets us
+    # preserve order, which a set() doesn't.
+
+    if elm not in lst:
+        lst.append(elm)
+
+def _decode_and_escape(b):
+    # Decodes the 'bytes' array 'b' as UTF-8 and backslash-escapes special
+    # characters
+
+    # Hacky but robust way to avoid double-escaping any '\' spit out by
+    # 'backslashreplace' bytes.translate() can't map to more than a single
+    # byte, but str.translate() can map to more than one character, so it's
+    # nice here. There's probably a nicer way to do this.
+    return b.decode("utf-8", "surrogateescape") \
+            .translate(_escape_table) \
+            .encode("utf-8", "surrogateescape") \
+            .decode("utf-8", "backslashreplace")
+
+def _root_and_path_to_node(cur, path, fullpath):
+    # Returns the node pointed at by 'path', relative to the Node 'cur'. For
+    # example, if 'cur' has path /foo/bar, and 'path' is "baz/qaz", then the
+    # node with path /foo/bar/baz/qaz is returned. 'fullpath' is the path as
+    # given in the .dts file, for error messages.
+
+    for component in path.split("/"):
+        # Collapse multiple / in a row, and allow a / at the end
+        if not component:
+            continue
+
+        if component not in cur.nodes:
+            _err("component '{}' in path '{}' does not exist"
+                 .format(component, fullpath))
+
+        cur = cur.nodes[component]
+
+    return cur
+
+def _err(msg) -> NoReturn:
+    raise DTError(msg)
+
+_escape_table = str.maketrans({
+    "\\": "\\\\",
+    '"': '\\"',
+    "\a": "\\a",
+    "\b": "\\b",
+    "\t": "\\t",
+    "\n": "\\n",
+    "\v": "\\v",
+    "\f": "\\f",
+    "\r": "\\r"})
+
+# Lexer states
+_DEFAULT = 0
+_EXPECT_PROPNODENAME = 1
+_EXPECT_BYTE = 2
+
+_num_re = re.compile(r"(0[xX][0-9a-fA-F]+|[0-9]+)(?:ULL|UL|LL|U|L)?")
+
+# A leading \ is allowed property and node names, probably to allow weird node
+# names that would clash with other stuff
+_propnodename_re = re.compile(r"\\?([a-zA-Z0-9,._+*#?@-]+)")
+
+# Misc. tokens that are tried after a property/node name. This is important, as
+# there's overlap with the allowed characters in names.
+_misc_re = re.compile(
+    "|".join(re.escape(pat) for pat in (
+        "==", "!=", "!", "=", ",", ";", "+", "-", "*", "/", "%", "~", "?", ":",
+        "^", "(", ")", "{", "}", "[", "]", "<<", "<=", "<", ">>", ">=", ">",
+        "||", "|", "&&", "&")))
+
+_byte_re = re.compile(r"[0-9a-fA-F]{2}")
+
+# Matches a backslash escape within a 'bytes' array. Captures the 'c' part of
+# '\c', where c might be a single character or an octal/hex escape.
+_unescape_re = re.compile(br'\\([0-7]{1,3}|x[0-9A-Fa-f]{1,2}|.)')
+
+# #line directive (this is the regex the C tools use)
+_line_re = re.compile(
+    r'^#(?:line)?[ \t]+([0-9]+)[ \t]+"((?:[^\\"]|\\.)*)"(?:[ \t]+[0-9]+)?',
+    re.MULTILINE)
+
+def _init_tokens():
+    # Builds a (<token 1>)|(<token 2>)|... regex and returns it. The
+    # way this is constructed makes the token's value as an int appear
+    # in match.lastindex after a match.
+
+    # Each pattern must have exactly one capturing group, which can capture any
+    # part of the pattern. This makes match.lastindex match the token type.
+    # _Token.val is based on the captured string.
+    token_spec = {
+        _T.INCLUDE: r'(/include/\s*"(?:[^\\"]|\\.)*")',
+        # #line directive
+        _T.LINE:
+        r'^#(?:line)?[ \t]+([0-9]+[ \t]+"(?:[^\\"]|\\.)*")(?:[ \t]+[0-9]+)?',
+
+        _T.STRING: r'"((?:[^\\"]|\\.)*)"',
+        _T.DTS_V1: r"(/dts-v1/)",
+        _T.PLUGIN: r"(/plugin/)",
+        _T.MEMRESERVE: r"(/memreserve/)",
+        _T.BITS: r"(/bits/)",
+        _T.DEL_PROP: r"(/delete-property/)",
+        _T.DEL_NODE: r"(/delete-node/)",
+        _T.OMIT_IF_NO_REF: r"(/omit-if-no-ref/)",
+        _T.LABEL: r"([a-zA-Z_][a-zA-Z0-9_]*):",
+        _T.CHAR_LITERAL: r"'((?:[^\\']|\\.)*)'",
+        _T.REF: r"&([a-zA-Z_][a-zA-Z0-9_]*|{[a-zA-Z0-9,._+*#?@/-]*})",
+        _T.INCBIN: r"(/incbin/)",
+        # Whitespace, C comments, and C++ comments
+        _T.SKIP: r"(\s+|(?:/\*(?:.|\n)*?\*/)|//.*$)",
+        # Return a token for end-of-file so that the parsing code can
+        # always assume that there are more tokens when looking
+        # ahead. This simplifies things.
+        _T.EOF: r"(\Z)",
+    }
+
+    # MULTILINE is needed for C++ comments and #line directives
+    return re.compile("|".join(token_spec[tok_id] for tok_id in
+                               range(1, _T.EOF + 1)),
+                      re.MULTILINE | re.ASCII)
+
+_token_re = _init_tokens()
+
+_TYPE_TO_N_BYTES = {
+    _MarkerType.UINT8: 1,
+    _MarkerType.UINT16: 2,
+    _MarkerType.UINT32: 4,
+    _MarkerType.UINT64: 8,
+}
+
+_N_BYTES_TO_TYPE = {
+    1: _MarkerType.UINT8,
+    2: _MarkerType.UINT16,
+    4: _MarkerType.UINT32,
+    8: _MarkerType.UINT64,
+}
+
+_N_BYTES_TO_START_STR = {
+    1: " [",
+    2: " /bits/ 16 <",
+    4: " <",
+    8: " /bits/ 64 <",
+}
+
+_N_BYTES_TO_END_STR = {
+    1: " ]",
+    2: " >",
+    4: " >",
+    8: " >",
+}
diff --git a/tools/dts/python-devicetree/src/devicetree/edtlib.py b/tools/dts/python-devicetree/src/devicetree/edtlib.py
new file mode 100644
index 0000000000000000000000000000000000000000..57daf1b4afe55619e084d1ba2cdb24813961934f
--- /dev/null
+++ b/tools/dts/python-devicetree/src/devicetree/edtlib.py
@@ -0,0 +1,2830 @@
+# Copyright (c) 2019 Nordic Semiconductor ASA
+# Copyright (c) 2019 Linaro Limited
+# SPDX-License-Identifier: BSD-3-Clause
+
+# Tip: You can view just the documentation with 'pydoc3 devicetree.edtlib'
+
+"""
+Library for working with devicetrees at a higher level compared to dtlib. Like
+dtlib, this library presents a tree of devicetree nodes, but the nodes are
+augmented with information from bindings and include some interpretation of
+properties. Some of this interpretation is based on conventions established
+by the Linux kernel, so the Documentation/devicetree/bindings in the Linux
+source code is sometimes good reference material.
+
+Bindings are YAML files that describe devicetree nodes. Devicetree
+nodes are usually mapped to bindings via their 'compatible = "..."' property,
+but a binding can also come from a 'child-binding:' key in the binding for the
+parent devicetree node.
+
+Each devicetree node (dtlib.Node) gets a corresponding edtlib.Node instance,
+which has all the information related to the node.
+
+The top-level entry points for the library are the EDT and Binding classes.
+See their constructor docstrings for details. There is also a
+bindings_from_paths() helper function.
+"""
+
+# NOTE: tests/test_edtlib.py is the test suite for this library.
+
+# Implementation notes
+# --------------------
+#
+# A '_' prefix on an identifier in Python is a convention for marking it private.
+# Please do not access private things. Instead, think of what API you need, and
+# add it.
+#
+# This module is not meant to have any global state. It should be possible to
+# create several EDT objects with independent binding paths and flags. If you
+# need to add a configuration parameter or the like, store it in the EDT
+# instance, and initialize it e.g. with a constructor argument.
+#
+# This library is layered on top of dtlib, and is not meant to expose it to
+# clients. This keeps the header generation script simple.
+#
+# General biased advice:
+#
+# - Consider using @property for APIs that don't need parameters. It makes
+#   functions look like attributes, which is less awkward in clients, and makes
+#   it easy to switch back and forth between variables and functions.
+#
+# - Think about the data type of the thing you're exposing. Exposing something
+#   as e.g. a list or a dictionary is often nicer and more flexible than adding
+#   a function.
+#
+# - Avoid get_*() prefixes on functions. Name them after the thing they return
+#   instead. This often makes the code read more naturally in callers.
+#
+#   Also, consider using @property instead of get_*().
+#
+# - Don't expose dtlib stuff directly.
+#
+# - Add documentation for any new APIs you add.
+#
+#   The convention here is that docstrings (quoted strings) are used for public
+#   APIs, and "doc comments" for internal functions.
+#
+#   @properties are documented in the class docstring, as if they were
+#   variables. See the existing @properties for a template.
+
+from collections import OrderedDict, defaultdict
+from copy import deepcopy
+import logging
+import os
+import re
+from typing import Set
+
+import yaml
+try:
+    # Use the C LibYAML parser if available, rather than the Python parser.
+    # This makes e.g. gen_defines.py more than twice as fast.
+    from yaml import CLoader as Loader
+except ImportError:
+    from yaml import Loader     # type: ignore
+
+from devicetree.dtlib import DT, DTError, to_num, to_nums, Type
+from devicetree.grutils import Graph
+
+
+#
+# Public classes
+#
+
+
+class EDT:
+    """
+    Represents a devicetree augmented with information from bindings.
+
+    These attributes are available on EDT objects:
+
+    nodes:
+      A list of Node objects for the nodes that appear in the devicetree
+
+    compat2nodes:
+      A collections.defaultdict that maps each 'compatible' string that appears
+      on some Node to a list of Nodes with that compatible.
+
+    compat2okay:
+      Like compat2nodes, but just for nodes with status 'okay'.
+
+    label2node:
+      A collections.OrderedDict that maps a node label to the node with
+      that label.
+
+    dep_ord2node:
+      A collections.OrderedDict that maps an ordinal to the node with
+      that dependency ordinal.
+
+    chosen_nodes:
+      A collections.OrderedDict that maps the properties defined on the
+      devicetree's /chosen node to their values. 'chosen' is indexed by
+      property name (a string), and values are converted to Node objects.
+      Note that properties of the /chosen node which can't be converted
+      to a Node are not included in the value.
+
+    dts_path:
+      The .dts path passed to __init__()
+
+    dts_source:
+      The final DTS source code of the loaded devicetree after merging nodes
+      and processing /delete-node/ and /delete-property/, as a string
+
+    bindings_dirs:
+      The bindings directory paths passed to __init__()
+
+    scc_order:
+      A list of lists of Nodes. All elements of each list
+      depend on each other, and the Nodes in any list do not depend
+      on any Node in a subsequent list. Each list defines a Strongly
+      Connected Component (SCC) of the graph.
+
+      For an acyclic graph each list will be a singleton. Cycles
+      will be represented by lists with multiple nodes. Cycles are
+      not expected to be present in devicetree graphs.
+
+    The standard library's pickle module can be used to marshal and
+    unmarshal EDT objects.
+    """
+    def __init__(self, dts, bindings_dirs,
+                 warn_reg_unit_address_mismatch=True,
+                 default_prop_types=True,
+                 support_fixed_partitions_on_any_bus=True,
+                 infer_binding_for_paths=None,
+                 vendor_prefixes=None,
+                 werror=False):
+        """EDT constructor.
+
+        dts:
+          Path to devicetree .dts file
+
+        bindings_dirs:
+          List of paths to directories containing bindings, in YAML format.
+          These directories are recursively searched for .yaml files.
+
+        warn_reg_unit_address_mismatch (default: True):
+          If True, a warning is logged if a node has a 'reg' property where
+          the address of the first entry does not match the unit address of the
+          node
+
+        default_prop_types (default: True):
+          If True, default property types will be used when a node has no
+          bindings.
+
+        support_fixed_partitions_on_any_bus (default True):
+          If True, set the Node.bus for 'fixed-partitions' compatible nodes
+          to None.  This allows 'fixed-partitions' binding to match regardless
+          of the bus the 'fixed-partition' is under.
+
+        infer_binding_for_paths (default: None):
+          An iterable of devicetree paths identifying nodes for which bindings
+          should be inferred from the node content.  (Child nodes are not
+          processed.)  Pass none if no nodes should support inferred bindings.
+
+        vendor_prefixes (default: None):
+          A dict mapping vendor prefixes in compatible properties to their
+          descriptions. If given, compatibles in the form "manufacturer,device"
+          for which "manufacturer" is neither a key in the dict nor a specially
+          exempt set of grandfathered-in cases will cause warnings.
+
+        werror (default: False):
+          If True, some edtlib specific warnings become errors. This currently
+          errors out if 'dts' has any deprecated properties set, or an unknown
+          vendor prefix is used.
+        """
+        self._warn_reg_unit_address_mismatch = warn_reg_unit_address_mismatch
+        self._default_prop_types = default_prop_types
+        self._fixed_partitions_no_bus = support_fixed_partitions_on_any_bus
+        self._infer_binding_for_paths = set(infer_binding_for_paths or [])
+        self._werror = bool(werror)
+        self._vendor_prefixes = vendor_prefixes
+
+        self.dts_path = dts
+        self.bindings_dirs = bindings_dirs
+
+        self._dt = DT(dts)
+        _check_dt(self._dt)
+
+        self._init_compat2binding()
+        self._init_nodes()
+        self._init_graph()
+        self._init_luts()
+
+        self._check()
+
+    def get_node(self, path):
+        """
+        Returns the Node at the DT path or alias 'path'. Raises EDTError if the
+        path or alias doesn't exist.
+        """
+        try:
+            return self._node2enode[self._dt.get_node(path)]
+        except DTError as e:
+            _err(e)
+
+    @property
+    def chosen_nodes(self):
+        ret = OrderedDict()
+
+        try:
+            chosen = self._dt.get_node("/chosen")
+        except DTError:
+            return ret
+
+        for name, prop in chosen.props.items():
+            try:
+                node = prop.to_path()
+            except DTError:
+                # DTS value is not phandle or string, or path doesn't exist
+                continue
+
+            ret[name] = self._node2enode[node]
+
+        return ret
+
+    def chosen_node(self, name):
+        """
+        Returns the Node pointed at by the property named 'name' in /chosen, or
+        None if the property is missing
+        """
+        return self.chosen_nodes.get(name)
+
+    @property
+    def dts_source(self):
+        return f"{self._dt}"
+
+    def __repr__(self):
+        return "<EDT for '{}', binding directories '{}'>".format(
+            self.dts_path, self.bindings_dirs)
+
+    @property
+    def scc_order(self):
+        try:
+            return self._graph.scc_order()
+        except Exception as e:
+            raise EDTError(e)
+
+    def _init_graph(self):
+        # Constructs a graph of dependencies between Node instances,
+        # which is usable for computing a partial order over the dependencies.
+        # The algorithm supports detecting dependency loops.
+        #
+        # Actually computing the SCC order is lazily deferred to the
+        # first time the scc_order property is read.
+
+        self._graph = Graph()
+
+        for node in self.nodes:
+            # A Node always depends on its parent.
+            for child in node.children.values():
+                self._graph.add_edge(child, node)
+
+            # A Node depends on any Nodes present in 'phandle',
+            # 'phandles', or 'phandle-array' property values.
+            for prop in node.props.values():
+                if prop.type == 'phandle':
+                    self._graph.add_edge(node, prop.val)
+                elif prop.type == 'phandles':
+                    for phandle_node in prop.val:
+                        self._graph.add_edge(node, phandle_node)
+                elif prop.type == 'phandle-array':
+                    for cd in prop.val:
+                        if cd is None:
+                            continue
+                        self._graph.add_edge(node, cd.controller)
+
+            # A Node depends on whatever supports the interrupts it
+            # generates.
+            for intr in node.interrupts:
+                self._graph.add_edge(node, intr.controller)
+
+    def _init_compat2binding(self):
+        # Creates self._compat2binding, a dictionary that maps
+        # (<compatible>, <bus>) tuples (both strings) to Binding objects.
+        #
+        # The Binding objects are created from YAML files discovered
+        # in self.bindings_dirs as needed.
+        #
+        # For example, self._compat2binding["company,dev", "can"]
+        # contains the Binding for the 'company,dev' device, when it
+        # appears on the CAN bus.
+        #
+        # For bindings that don't specify a bus, <bus> is None, so that e.g.
+        # self._compat2binding["company,notonbus", None] is the Binding.
+        #
+        # Only bindings for 'compatible' strings that appear in the devicetree
+        # are loaded.
+
+        dt_compats = _dt_compats(self._dt)
+        # Searches for any 'compatible' string mentioned in the devicetree
+        # files, with a regex
+        dt_compats_search = re.compile(
+            "|".join(re.escape(compat) for compat in dt_compats)
+        ).search
+
+        self._binding_paths = _binding_paths(self.bindings_dirs)
+        self._binding_fname2path = {os.path.basename(path): path
+                                    for path in self._binding_paths}
+
+        self._compat2binding = {}
+        for binding_path in self._binding_paths:
+            with open(binding_path, encoding="utf-8") as f:
+                contents = f.read()
+
+            # As an optimization, skip parsing files that don't contain any of
+            # the .dts 'compatible' strings, which should be reasonably safe
+            if not dt_compats_search(contents):
+                continue
+
+            # Load the binding and check that it actually matches one of the
+            # compatibles. Might get false positives above due to comments and
+            # stuff.
+
+            try:
+                # Parsed PyYAML output (Python lists/dictionaries/strings/etc.,
+                # representing the file)
+                raw = yaml.load(contents, Loader=_BindingLoader)
+            except yaml.YAMLError as e:
+                _err(
+                        f"'{binding_path}' appears in binding directories "
+                        f"but isn't valid YAML: {e}")
+                continue
+
+            # Convert the raw data to a Binding object, erroring out
+            # if necessary.
+            binding = self._binding(raw, binding_path, dt_compats)
+
+            # Register the binding in self._compat2binding, along with
+            # any child bindings that have their own compatibles.
+            while binding is not None:
+                if binding.compatible:
+                    self._register_binding(binding)
+                binding = binding.child_binding
+
+    def _binding(self, raw, binding_path, dt_compats):
+        # Convert a 'raw' binding from YAML to a Binding object and return it.
+        #
+        # Error out if the raw data looks like an invalid binding.
+        #
+        # Return None if the file doesn't contain a binding or the
+        # binding's compatible isn't in dt_compats.
+
+        # Get the 'compatible:' string.
+        if raw is None or "compatible" not in raw:
+            # Empty file, binding fragment, spurious file, etc.
+            return None
+
+        compatible = raw["compatible"]
+
+        if compatible not in dt_compats:
+            # Not a compatible we care about.
+            return None
+
+        # Initialize and return the Binding object.
+        return Binding(binding_path, self._binding_fname2path, raw=raw)
+
+    def _register_binding(self, binding):
+        # Do not allow two different bindings to have the same
+        # 'compatible:'/'on-bus:' combo
+        old_binding = self._compat2binding.get((binding.compatible,
+                                                binding.on_bus))
+        if old_binding:
+            msg = (f"both {old_binding.path} and {binding.path} have "
+                   f"'compatible: {binding.compatible}'")
+            if binding.on_bus is not None:
+                msg += f" and 'on-bus: {binding.on_bus}'"
+            _err(msg)
+
+        # Register the binding.
+        self._compat2binding[binding.compatible, binding.on_bus] = binding
+
+    def _init_nodes(self):
+        # Creates a list of edtlib.Node objects from the dtlib.Node objects, in
+        # self.nodes
+
+        # Maps each dtlib.Node to its corresponding edtlib.Node
+        self._node2enode = {}
+
+        self.nodes = []
+
+        for dt_node in self._dt.node_iter():
+            # Warning: We depend on parent Nodes being created before their
+            # children. This is guaranteed by node_iter().
+            node = Node()
+            node.edt = self
+            node._node = dt_node
+            if "compatible" in node._node.props:
+                node.compats = node._node.props["compatible"].to_strings()
+            else:
+                node.compats = []
+            node.bus_node = node._bus_node(self._fixed_partitions_no_bus)
+            node._init_binding()
+            node._init_regs()
+
+            self.nodes.append(node)
+            self._node2enode[dt_node] = node
+
+        for node in self.nodes:
+            # These depend on all Node objects having been created, because
+            # they (either always or sometimes) reference other nodes, so we
+            # run them separately
+            node._init_props(default_prop_types=self._default_prop_types,
+                             err_on_deprecated=self._werror)
+            node._init_interrupts()
+            node._init_pinctrls()
+
+        if self._warn_reg_unit_address_mismatch:
+            # This warning matches the simple_bus_reg warning in dtc
+            for node in self.nodes:
+                if node.regs and node.regs[0].addr != node.unit_addr:
+                    _LOG.warning("unit address and first address in 'reg' "
+                                 f"(0x{node.regs[0].addr:x}) don't match for "
+                                 f"{node.path}")
+
+    def _init_luts(self):
+        # Initialize node lookup tables (LUTs).
+
+        self.label2node = OrderedDict()
+        self.dep_ord2node = OrderedDict()
+        self.compat2nodes = defaultdict(list)
+        self.compat2okay = defaultdict(list)
+
+        for node in self.nodes:
+            for label in node.labels:
+                self.label2node[label] = node
+
+            for compat in node.compats:
+                self.compat2nodes[compat].append(node)
+
+                if node.status == "okay":
+                    self.compat2okay[compat].append(node)
+
+        for nodeset in self.scc_order:
+            node = nodeset[0]
+            self.dep_ord2node[node.dep_ordinal] = node
+
+    def _check(self):
+        # Tree-wide checks and warnings.
+
+        for binding in self._compat2binding.values():
+            for spec in binding.prop2specs.values():
+                if not spec.enum or spec.type != 'string':
+                    continue
+
+                if not spec.enum_tokenizable:
+                    _LOG.warning(
+                        f"compatible '{binding.compatible}' "
+                        f"in binding '{binding.path}' has non-tokenizable enum "
+                        f"for property '{spec.name}': " +
+                        ', '.join(repr(x) for x in spec.enum))
+                elif not spec.enum_upper_tokenizable:
+                    _LOG.warning(
+                        f"compatible '{binding.compatible}' "
+                        f"in binding '{binding.path}' has enum for property "
+                        f"'{spec.name}' that is only tokenizable "
+                        'in lowercase: ' +
+                        ', '.join(repr(x) for x in spec.enum))
+
+        # Validate the contents of compatible properties.
+        self._checked_compatibles: Set[str] = set()
+        for node in self.nodes:
+            if 'compatible' not in node.props:
+                continue
+
+            compatibles = node.props['compatible'].val
+
+            # _check() runs after _init_compat2binding() has called
+            # _dt_compats(), which already converted every compatible
+            # property to a list of strings. So we know 'compatibles'
+            # is a list, but add an assert for future-proofing.
+            assert isinstance(compatibles, list)
+
+            for compat in compatibles:
+                # This is also just for future-proofing.
+                assert isinstance(compat, str)
+
+                self._check_compatible(node, compat)
+        del self._checked_compatibles  # We have no need for this anymore.
+
+    def _check_compatible(self, node, compat):
+        if compat in self._checked_compatibles:
+            return
+
+        # The regular expression comes from dt-schema.
+        compat_re = r'^[a-zA-Z][a-zA-Z0-9,+\-._]+$'
+        if not re.match(compat_re, compat):
+            _err(f"node '{node.path}' compatible '{compat}' "
+                 'must match this regular expression: '
+                 f"'{compat_re}'")
+
+        if ',' in compat and self._vendor_prefixes is not None:
+            vendor = compat.split(',', 1)[0]
+            if vendor not in self._vendor_prefixes and \
+                   vendor not in _VENDOR_PREFIX_ALLOWED:
+                if self._werror:
+                    log_fn = _LOG.error
+                else:
+                    log_fn = _LOG.warning
+                log_fn(
+                    f"node '{node.path}' compatible '{compat}' "
+                    f"has unknown vendor prefix '{vendor}'")
+
+        self._checked_compatibles.add(compat)
+
+class Node:
+    """
+    Represents a devicetree node, augmented with information from bindings, and
+    with some interpretation of devicetree properties. There's a one-to-one
+    correspondence between devicetree nodes and Nodes.
+
+    These attributes are available on Node objects:
+
+    edt:
+      The EDT instance this node is from
+
+    name:
+      The name of the node
+
+    unit_addr:
+      An integer with the ...@<unit-address> portion of the node name,
+      translated through any 'ranges' properties on parent nodes, or None if
+      the node name has no unit-address portion
+
+    description:
+      The description string from the binding for the node, or None if the node
+      has no binding. Leading and trailing whitespace (including newlines) is
+      removed.
+
+    path:
+      The devicetree path of the node
+
+    label:
+      The text from the 'label' property on the node, or None if the node has
+      no 'label'
+
+    labels:
+      A list of all of the devicetree labels for the node, in the same order
+      as the labels appear, but with duplicates removed.
+
+      This corresponds to the actual devicetree source labels, unlike the
+      "label" attribute, which is the value of a devicetree property named
+      "label".
+
+    parent:
+      The Node instance for the devicetree parent of the Node, or None if the
+      node is the root node
+
+    children:
+      A dictionary with the Node instances for the devicetree children of the
+      node, indexed by name
+
+    dep_ordinal:
+      A non-negative integer value such that the value for a Node is
+      less than the value for all Nodes that depend on it.
+
+      The ordinal is defined for all Nodes, and is unique among nodes in its
+      EDT 'nodes' list.
+
+    required_by:
+      A list with the nodes that directly depend on the node
+
+    depends_on:
+      A list with the nodes that the node directly depends on
+
+    status:
+      The node's status property value, as a string, or "okay" if the node
+      has no status property set. If the node's status property is "ok",
+      it is converted to "okay" for consistency.
+
+    read_only:
+      True if the node has a 'read-only' property, and False otherwise
+
+    matching_compat:
+      The 'compatible' string for the binding that matched the node, or None if
+      the node has no binding
+
+    binding_path:
+      The path to the binding file for the node, or None if the node has no
+      binding
+
+    compats:
+      A list of 'compatible' strings for the node, in the same order that
+      they're listed in the .dts file
+
+    regs:
+      A list of Register objects for the node's registers
+
+    props:
+      A collections.OrderedDict that maps property names to Property objects.
+      Property objects are created for all devicetree properties on the node
+      that are mentioned in 'properties:' in the binding.
+
+    aliases:
+      A list of aliases for the node. This is fetched from the /aliases node.
+
+    interrupts:
+      A list of ControllerAndData objects for the interrupts generated by the
+      node. The list is empty if the node does not generate interrupts.
+
+    pinctrls:
+      A list of PinCtrl objects for the pinctrl-<index> properties on the
+      node, sorted by index. The list is empty if the node does not have any
+      pinctrl-<index> properties.
+
+    bus:
+      If the node is a bus node (has a 'bus:' key in its binding), then this
+      attribute holds the bus type, e.g. "i2c" or "spi". If the node is not a
+      bus node, then this attribute is None.
+
+    on_bus:
+      The bus the node appears on, e.g. "i2c" or "spi". The bus is determined
+      by searching upwards for a parent node whose binding has a 'bus:' key,
+      returning the value of the first 'bus:' key found. If none of the node's
+      parents has a 'bus:' key, this attribute is None.
+
+    bus_node:
+      Like on_bus, but contains the Node for the bus controller, or None if the
+      node is not on a bus.
+
+    flash_controller:
+      The flash controller for the node. Only meaningful for nodes representing
+      flash partitions.
+
+    spi_cs_gpio:
+      The device's SPI GPIO chip select as a ControllerAndData instance, if it
+      exists, and None otherwise. See
+      Documentation/devicetree/bindings/spi/spi-controller.yaml in the Linux kernel.
+    """
+    @property
+    def name(self):
+        "See the class docstring"
+        return self._node.name
+
+    @property
+    def unit_addr(self):
+        "See the class docstring"
+
+        # TODO: Return a plain string here later, like dtlib.Node.unit_addr?
+
+        if "@" not in self.name:
+            return None
+
+        try:
+            addr = int(self.name.split("@", 1)[1], 16)
+        except ValueError:
+            _err("{!r} has non-hex unit address".format(self))
+
+        return _translate(addr, self._node)
+
+    @property
+    def description(self):
+        "See the class docstring."
+        if self._binding:
+            return self._binding.description
+        return None
+
+    @property
+    def path(self):
+        "See the class docstring"
+        return self._node.path
+
+    @property
+    def label(self):
+        "See the class docstring"
+        if "label" in self._node.props:
+            return self._node.props["label"].to_string()
+        return None
+
+    @property
+    def labels(self):
+        "See the class docstring"
+        return self._node.labels
+
+    @property
+    def parent(self):
+        "See the class docstring"
+        return self.edt._node2enode.get(self._node.parent)
+
+    @property
+    def children(self):
+        "See the class docstring"
+        # Could be initialized statically too to preserve identity, but not
+        # sure if needed. Parent nodes being initialized before their children
+        # would need to be kept in mind.
+        return OrderedDict((name, self.edt._node2enode[node])
+                           for name, node in self._node.nodes.items())
+
+    @property
+    def required_by(self):
+        "See the class docstring"
+        return self.edt._graph.required_by(self)
+
+    @property
+    def depends_on(self):
+        "See the class docstring"
+        return self.edt._graph.depends_on(self)
+
+    @property
+    def status(self):
+        "See the class docstring"
+        status = self._node.props.get("status")
+
+        if status is None:
+            as_string = "okay"
+        else:
+            as_string = status.to_string()
+
+        if as_string == "ok":
+            as_string = "okay"
+
+        return as_string
+
+    @property
+    def read_only(self):
+        "See the class docstring"
+        return "read-only" in self._node.props
+
+    @property
+    def aliases(self):
+        "See the class docstring"
+        return [alias for alias, node in self._node.dt.alias2node.items()
+                if node is self._node]
+
+    @property
+    def bus(self):
+        "See the class docstring"
+        if self._binding:
+            return self._binding.bus
+        return None
+
+    @property
+    def on_bus(self):
+        "See the class docstring"
+        bus_node = self.bus_node
+        return bus_node.bus if bus_node else None
+
+    @property
+    def flash_controller(self):
+        "See the class docstring"
+
+        # The node path might be something like
+        # /flash-controller@4001E000/flash@0/partitions/partition@fc000. We go
+        # up two levels to get the flash and check its compat. The flash
+        # controller might be the flash itself (for cases like NOR flashes).
+        # For the case of 'soc-nv-flash', we assume the controller is the
+        # parent of the flash node.
+
+        if not self.parent or not self.parent.parent:
+            _err("flash partition {!r} lacks parent or grandparent node"
+                 .format(self))
+
+        controller = self.parent.parent
+        if controller.matching_compat == "soc-nv-flash":
+            return controller.parent
+        return controller
+
+    @property
+    def spi_cs_gpio(self):
+        "See the class docstring"
+
+        if not (self.on_bus == "spi" and "cs-gpios" in self.bus_node.props):
+            return None
+
+        if not self.regs:
+            _err("{!r} needs a 'reg' property, to look up the chip select index "
+                 "for SPI".format(self))
+
+        parent_cs_lst = self.bus_node.props["cs-gpios"].val
+
+        # cs-gpios is indexed by the unit address
+        cs_index = self.regs[0].addr
+        if cs_index >= len(parent_cs_lst):
+            _err("index from 'regs' in {!r} ({}) is >= number of cs-gpios "
+                 "in {!r} ({})".format(
+                     self, cs_index, self.bus_node, len(parent_cs_lst)))
+
+        return parent_cs_lst[cs_index]
+
+    def __repr__(self):
+        return "<Node {} in '{}', {}>".format(
+            self.path, self.edt.dts_path,
+            "binding " + self.binding_path if self.binding_path
+                else "no binding")
+
+    def _init_binding(self):
+        # Initializes Node.matching_compat, Node._binding, and
+        # Node.binding_path.
+        #
+        # Node._binding holds the data from the node's binding file, in the
+        # format returned by PyYAML (plain Python lists, dicts, etc.), or None
+        # if the node has no binding.
+
+        # This relies on the parent of the node having already been
+        # initialized, which is guaranteed by going through the nodes in
+        # node_iter() order.
+
+        if self.path in self.edt._infer_binding_for_paths:
+            self._binding_from_properties()
+            return
+
+        if self.compats:
+            on_bus = self.on_bus
+
+            for compat in self.compats:
+                # When matching, respect the order of the 'compatible' entries,
+                # and for each one first try to match against an explicitly
+                # specified bus (if any) and then against any bus. This is so
+                # that matching against bindings which do not specify a bus
+                # works the same way in Zephyr as it does elsewhere.
+                if (compat, on_bus) in self.edt._compat2binding:
+                    binding = self.edt._compat2binding[compat, on_bus]
+                elif (compat, None) in self.edt._compat2binding:
+                    binding = self.edt._compat2binding[compat, None]
+                else:
+                    continue
+
+                self.binding_path = binding.path
+                self.matching_compat = compat
+                self._binding = binding
+                return
+        else:
+            # No 'compatible' property. See if the parent binding has
+            # a compatible. This can come from one or more levels of
+            # nesting with 'child-binding:'.
+
+            binding_from_parent = self._binding_from_parent()
+            if binding_from_parent:
+                self._binding = binding_from_parent
+                self.binding_path = self._binding.path
+                self.matching_compat = self._binding.compatible
+
+                return
+
+        # No binding found
+        self._binding = self.binding_path = self.matching_compat = None
+
+    def _binding_from_properties(self):
+        # Sets up a Binding object synthesized from the properties in the node.
+
+        if self.compats:
+            _err(f"compatible in node with inferred binding: {self.path}")
+
+        # Synthesize a 'raw' binding as if it had been parsed from YAML.
+        raw = {
+            'description': 'Inferred binding from properties, via edtlib.',
+            'properties': {},
+        }
+        for name, prop in self._node.props.items():
+            pp = OrderedDict()
+            if prop.type == Type.EMPTY:
+                pp["type"] = "boolean"
+            elif prop.type == Type.BYTES:
+                pp["type"] = "uint8-array"
+            elif prop.type == Type.NUM:
+                pp["type"] = "int"
+            elif prop.type == Type.NUMS:
+                pp["type"] = "array"
+            elif prop.type == Type.STRING:
+                pp["type"] = "string"
+            elif prop.type == Type.STRINGS:
+                pp["type"] = "string-array"
+            elif prop.type == Type.PHANDLE:
+                pp["type"] = "phandle"
+            elif prop.type == Type.PHANDLES:
+                pp["type"] = "phandles"
+            elif prop.type == Type.PHANDLES_AND_NUMS:
+                pp["type"] = "phandle-array"
+            elif prop.type == Type.PATH:
+                pp["type"] = "path"
+            else:
+                _err(f"cannot infer binding from property: {prop} "
+                     f"with type {prop.type!r}")
+            raw['properties'][name] = pp
+
+        # Set up Node state.
+        self.binding_path = None
+        self.matching_compat = None
+        self.compats = []
+        self._binding = Binding(None, {}, raw=raw, require_compatible=False)
+
+    def _binding_from_parent(self):
+        # Returns the binding from 'child-binding:' in the parent node's
+        # binding.
+
+        if not self.parent:
+            return None
+
+        pbinding = self.parent._binding
+        if not pbinding:
+            return None
+
+        if pbinding.child_binding:
+            return pbinding.child_binding
+
+        return None
+
+    def _bus_node(self, support_fixed_partitions_on_any_bus = True):
+        # Returns the value for self.bus_node. Relies on parent nodes being
+        # initialized before their children.
+
+        if not self.parent:
+            # This is the root node
+            return None
+
+        # Treat 'fixed-partitions' as if they are not on any bus.  The reason is
+        # that flash nodes might be on a SPI or controller or SoC bus.  Having
+        # bus be None means we'll always match the binding for fixed-partitions
+        # also this means want processing the fixed-partitions node we wouldn't
+        # try to do anything bus specific with it.
+        if support_fixed_partitions_on_any_bus and "fixed-partitions" in self.compats:
+            return None
+
+        if self.parent.bus:
+            # The parent node is a bus node
+            return self.parent
+
+        # Same bus node as parent (possibly None)
+        return self.parent.bus_node
+
+    def _init_props(self, default_prop_types=False, err_on_deprecated=False):
+        # Creates self.props. See the class docstring. Also checks that all
+        # properties on the node are declared in its binding.
+
+        self.props = OrderedDict()
+
+        node = self._node
+        if self._binding:
+            prop2specs = self._binding.prop2specs
+        else:
+            prop2specs = None
+
+        # Initialize self.props
+        if prop2specs:
+            for prop_spec in prop2specs.values():
+                self._init_prop(prop_spec, err_on_deprecated)
+            self._check_undeclared_props()
+        elif default_prop_types:
+            for name in node.props:
+                if name not in _DEFAULT_PROP_SPECS:
+                    continue
+                prop_spec = _DEFAULT_PROP_SPECS[name]
+                val = self._prop_val(name, prop_spec.type, False, False, None,
+                                     err_on_deprecated)
+                self.props[name] = Property(prop_spec, val, self)
+
+    def _init_prop(self, prop_spec, err_on_deprecated):
+        # _init_props() helper for initializing a single property.
+        # 'prop_spec' is a PropertySpec object from the node's binding.
+
+        name = prop_spec.name
+        prop_type = prop_spec.type
+        if not prop_type:
+            _err("'{}' in {} lacks 'type'".format(name, self.binding_path))
+
+        val = self._prop_val(name, prop_type, prop_spec.deprecated,
+                             prop_spec.required, prop_spec.default,
+                             err_on_deprecated)
+
+        if val is None:
+            # 'required: false' property that wasn't there, or a property type
+            # for which we store no data.
+            return
+
+        enum = prop_spec.enum
+        if enum and val not in enum:
+            _err("value of property '{}' on {} in {} ({!r}) is not in 'enum' "
+                 "list in {} ({!r})"
+                 .format(name, self.path, self.edt.dts_path, val,
+                         self.binding_path, enum))
+
+        const = prop_spec.const
+        if const is not None and val != const:
+            _err("value of property '{}' on {} in {} ({!r}) is different from "
+                 "the 'const' value specified in {} ({!r})"
+                 .format(name, self.path, self.edt.dts_path, val,
+                         self.binding_path, const))
+
+        # Skip properties that start with '#', like '#size-cells', and mapping
+        # properties like 'gpio-map'/'interrupt-map'
+        if name[0] == "#" or name.endswith("-map"):
+            return
+
+        self.props[name] = Property(prop_spec, val, self)
+
+    def _prop_val(self, name, prop_type, deprecated, required, default,
+                  err_on_deprecated):
+        # _init_prop() helper for getting the property's value
+        #
+        # name:
+        #   Property name from binding
+        #
+        # prop_type:
+        #   Property type from binding (a string like "int")
+        #
+        # deprecated:
+        #   True if the property is deprecated
+        #
+        # required:
+        #   True if the property is required to exist
+        #
+        # default:
+        #   Default value to use when the property doesn't exist, or None if
+        #   the binding doesn't give a default value
+        #
+        # err_on_deprecated:
+        #   If True, a deprecated property is an error instead of warning.
+
+        node = self._node
+        prop = node.props.get(name)
+
+        if prop and deprecated:
+            msg = (f"'{name}' is marked as deprecated in 'properties:' "
+                   f"in {self.binding_path} for node {node.path}.")
+            if err_on_deprecated:
+                _err(msg)
+            else:
+                _LOG.warning(msg)
+
+        if not prop:
+            if required and self.status == "okay":
+                _err("'{}' is marked as required in 'properties:' in {}, but "
+                     "does not appear in {!r}".format(
+                         name, self.binding_path, node))
+
+            if default is not None:
+                # YAML doesn't have a native format for byte arrays. We need to
+                # convert those from an array like [0x12, 0x34, ...]. The
+                # format has already been checked in
+                # _check_prop_type_and_default().
+                if prop_type == "uint8-array":
+                    return bytes(default)
+                return default
+
+            return False if prop_type == "boolean" else None
+
+        if prop_type == "boolean":
+            if prop.type != Type.EMPTY:
+                _err("'{0}' in {1!r} is defined with 'type: boolean' in {2}, "
+                     "but is assigned a value ('{3}') instead of being empty "
+                     "('{0};')".format(name, node, self.binding_path, prop))
+            return True
+
+        if prop_type == "int":
+            return prop.to_num()
+
+        if prop_type == "array":
+            return prop.to_nums()
+
+        if prop_type == "uint8-array":
+            return prop.to_bytes()
+
+        if prop_type == "string":
+            return prop.to_string()
+
+        if prop_type == "string-array":
+            return prop.to_strings()
+
+        if prop_type == "phandle":
+            return self.edt._node2enode[prop.to_node()]
+
+        if prop_type == "phandles":
+            return [self.edt._node2enode[node] for node in prop.to_nodes()]
+
+        if prop_type == "phandle-array":
+            # This type is a bit high-level for dtlib as it involves
+            # information from bindings and *-names properties, so there's no
+            # to_phandle_array() in dtlib. Do the type check ourselves.
+            if prop.type not in (Type.PHANDLE, Type.PHANDLES, Type.PHANDLES_AND_NUMS):
+                _err(f"expected property '{name}' in {node.path} in "
+                     f"{node.dt.filename} to be assigned "
+                     f"with '{name} = < &foo ... &bar 1 ... &baz 2 3 >' "
+                     f"(a mix of phandles and numbers), not '{prop}'")
+
+            return self._standard_phandle_val_list(prop)
+
+        if prop_type == "path":
+            return self.edt._node2enode[prop.to_path()]
+
+        # prop_type == "compound". Checking that the 'type:'
+        # value is valid is done in _check_prop_type_and_default().
+        #
+        # 'compound' is a dummy type for properties that don't fit any of the
+        # patterns above, so that we can require all entries in 'properties:'
+        # to have a 'type: ...'. No Property object is created for it.
+        return None
+
+    def _check_undeclared_props(self):
+        # Checks that all properties are declared in the binding
+
+        for prop_name in self._node.props:
+            # Allow a few special properties to not be declared in the binding
+            if prop_name.endswith("-controller") or \
+               prop_name.startswith("#") or \
+               prop_name.startswith("pinctrl-") or \
+               prop_name in {
+                   "compatible", "status", "ranges", "phandle",
+                   "interrupt-parent", "interrupts-extended", "device_type"}:
+                continue
+
+            if prop_name not in self._binding.prop2specs:
+                _err("'{}' appears in {} in {}, but is not declared in "
+                     "'properties:' in {}"
+                     .format(prop_name, self._node.path, self.edt.dts_path,
+                             self.binding_path))
+
+    def _init_regs(self):
+        # Initializes self.regs
+
+        node = self._node
+
+        self.regs = []
+
+        if "reg" not in node.props:
+            return
+
+        address_cells = _address_cells(node)
+        size_cells = _size_cells(node)
+
+        for raw_reg in _slice(node, "reg", 4*(address_cells + size_cells),
+                              "4*(<#address-cells> (= {}) + <#size-cells> (= {}))"
+                              .format(address_cells, size_cells)):
+            reg = Register()
+            reg.node = self
+            if address_cells == 0:
+                reg.addr = None
+            else:
+                reg.addr = _translate(to_num(raw_reg[:4*address_cells]), node)
+            if size_cells == 0:
+                reg.size = None
+            else:
+                reg.size = to_num(raw_reg[4*address_cells:])
+            if size_cells != 0 and reg.size == 0:
+                _err("zero-sized 'reg' in {!r} seems meaningless (maybe you "
+                     "want a size of one or #size-cells = 0 instead)"
+                     .format(self._node))
+
+            self.regs.append(reg)
+
+        _add_names(node, "reg", self.regs)
+
+    def _init_pinctrls(self):
+        # Initializes self.pinctrls from any pinctrl-<index> properties
+
+        node = self._node
+
+        # pinctrl-<index> properties
+        pinctrl_props = [prop for name, prop in node.props.items()
+                         if re.match("pinctrl-[0-9]+", name)]
+        # Sort by index
+        pinctrl_props.sort(key=lambda prop: prop.name)
+
+        # Check indices
+        for i, prop in enumerate(pinctrl_props):
+            if prop.name != "pinctrl-" + str(i):
+                _err("missing 'pinctrl-{}' property on {!r} - indices should "
+                     "be contiguous and start from zero".format(i, node))
+
+        self.pinctrls = []
+        for prop in pinctrl_props:
+            pinctrl = PinCtrl()
+            pinctrl.node = self
+            pinctrl.conf_nodes = [
+                self.edt._node2enode[node] for node in prop.to_nodes()
+            ]
+            self.pinctrls.append(pinctrl)
+
+        _add_names(node, "pinctrl", self.pinctrls)
+
+    def _init_interrupts(self):
+        # Initializes self.interrupts
+
+        node = self._node
+
+        self.interrupts = []
+
+        for controller_node, data in _interrupts(node):
+            interrupt = ControllerAndData()
+            interrupt.node = self
+            interrupt.controller = self.edt._node2enode[controller_node]
+            interrupt.data = self._named_cells(interrupt.controller, data,
+                                               "interrupt")
+
+            self.interrupts.append(interrupt)
+
+        _add_names(node, "interrupt", self.interrupts)
+
+    def _standard_phandle_val_list(self, prop):
+        # Parses a property like
+        #
+        #     <name>s = <phandle value phandle value ...>
+        #     (e.g., pwms = <&foo 1 2 &bar 3 4>)
+        #
+        # , where each phandle points to a node that has a
+        #
+        #     #<name>-cells = <size>
+        #
+        # property that gives the number of cells in the value after the
+        # phandle. These values are given names in *-cells in the binding for
+        # the controller.
+        #
+        # Also parses any
+        #
+        #     <name>-names = "...", "...", ...
+        #
+        # Returns a list of Optional[ControllerAndData] instances.
+        # An index is None if the underlying phandle-array element
+        # is unspecified.
+
+        if prop.name.endswith("gpios"):
+            # There's some slight special-casing for *-gpios properties in that
+            # e.g. foo-gpios still maps to #gpio-cells rather than
+            # #foo-gpio-cells
+            basename = "gpio"
+        else:
+            # Strip -s. We've already checked that the property names end in -s
+            # in _check_prop_type_and_default().
+            basename = prop.name[:-1]
+
+        res = []
+
+        for item in _phandle_val_list(prop, basename):
+            if item is None:
+                res.append(None)
+                continue
+
+            controller_node, data = item
+            mapped_controller, mapped_data = \
+                _map_phandle_array_entry(prop.node, controller_node, data,
+                                         basename)
+
+            entry = ControllerAndData()
+            entry.node = self
+            entry.controller = self.edt._node2enode[mapped_controller]
+            entry.data = self._named_cells(entry.controller, mapped_data,
+                                           basename)
+
+            res.append(entry)
+
+        _add_names(self._node, basename, res)
+
+        return res
+
+    def _named_cells(self, controller, data, basename):
+        # Returns a dictionary that maps <basename>-cells names given in the
+        # binding for 'controller' to cell values. 'data' is the raw data, as a
+        # byte array.
+
+        if not controller._binding:
+            _err("{} controller {!r} for {!r} lacks binding"
+                 .format(basename, controller._node, self._node))
+
+        if basename in controller._binding.specifier2cells:
+            cell_names = controller._binding.specifier2cells[basename]
+        else:
+            # Treat no *-cells in the binding the same as an empty *-cells, so
+            # that bindings don't have to have e.g. an empty 'clock-cells:' for
+            # '#clock-cells = <0>'.
+            cell_names = []
+
+        data_list = to_nums(data)
+        if len(data_list) != len(cell_names):
+            _err("unexpected '{}-cells:' length in binding for {!r} - {} "
+                 "instead of {}"
+                 .format(basename, controller._node, len(cell_names),
+                         len(data_list)))
+
+        return OrderedDict(zip(cell_names, data_list))
+
+
+class Register:
+    """
+    Represents a register on a node.
+
+    These attributes are available on Register objects:
+
+    node:
+      The Node instance this register is from
+
+    name:
+      The name of the register as given in the 'reg-names' property, or None if
+      there is no 'reg-names' property
+
+    addr:
+      The starting address of the register, in the parent address space, or None
+      if #address-cells is zero. Any 'ranges' properties are taken into account.
+
+    size:
+      The length of the register in bytes
+    """
+    def __repr__(self):
+        fields = []
+
+        if self.name is not None:
+            fields.append("name: " + self.name)
+        if self.addr is not None:
+            fields.append("addr: " + hex(self.addr))
+        if self.size is not None:
+            fields.append("size: " + hex(self.size))
+
+        return "<Register, {}>".format(", ".join(fields))
+
+
+class ControllerAndData:
+    """
+    Represents an entry in an 'interrupts' or 'type: phandle-array' property
+    value, e.g. <&ctrl-1 4 0> in
+
+        cs-gpios = <&ctrl-1 4 0 &ctrl-2 3 4>;
+
+    These attributes are available on ControllerAndData objects:
+
+    node:
+      The Node instance the property appears on
+
+    controller:
+      The Node instance for the controller (e.g. the controller the interrupt
+      gets sent to for interrupts)
+
+    data:
+      A dictionary that maps names from the *-cells key in the binding for the
+      controller to data values, e.g. {"pin": 4, "flags": 0} for the example
+      above.
+
+      'interrupts = <1 2>' might give {"irq": 1, "level": 2}.
+
+    name:
+      The name of the entry as given in
+      'interrupt-names'/'gpio-names'/'pwm-names'/etc., or None if there is no
+      *-names property
+    """
+    def __repr__(self):
+        fields = []
+
+        if self.name is not None:
+            fields.append("name: " + self.name)
+
+        fields.append("controller: {}".format(self.controller))
+        fields.append("data: {}".format(self.data))
+
+        return "<ControllerAndData, {}>".format(", ".join(fields))
+
+
+class PinCtrl:
+    """
+    Represents a pin control configuration for a set of pins on a device,
+    e.g. pinctrl-0 or pinctrl-1.
+
+    These attributes are available on PinCtrl objects:
+
+    node:
+      The Node instance the pinctrl-* property is on
+
+    name:
+      The name of the configuration, as given in pinctrl-names, or None if
+      there is no pinctrl-names property
+
+    conf_nodes:
+      A list of Node instances for the pin configuration nodes, e.g.
+      the nodes pointed at by &state_1 and &state_2 in
+
+          pinctrl-0 = <&state_1 &state_2>;
+    """
+    def __repr__(self):
+        fields = []
+
+        if self.name is not None:
+            fields.append("name: " + self.name)
+
+        fields.append("configuration nodes: " + str(self.conf_nodes))
+
+        return "<PinCtrl, {}>".format(", ".join(fields))
+
+
+class Property:
+    """
+    Represents a property on a Node, as set in its DT node and with
+    additional info from the 'properties:' section of the binding.
+
+    Only properties mentioned in 'properties:' get created. Properties of type
+    'compound' currently do not get Property instances, as it's not clear
+    what to generate for them.
+
+    These attributes are available on Property objects. Several are
+    just convenience accessors for attributes on the PropertySpec object
+    accessible via the 'spec' attribute.
+
+    These attributes are available on Property objects:
+
+    node:
+      The Node instance the property is on
+
+    spec:
+      The PropertySpec object which specifies this property.
+
+    name:
+      Convenience for spec.name.
+
+    description:
+      Convenience for spec.name with leading and trailing whitespace
+      (including newlines) removed.
+
+    type:
+      Convenience for spec.type.
+
+    val:
+      The value of the property, with the format determined by spec.type,
+      which comes from the 'type:' string in the binding.
+
+        - For 'type: int/array/string/string-array', 'val' is what you'd expect
+          (a Python integer or string, or a list of them)
+
+        - For 'type: phandle' and 'type: path', 'val' is the pointed-to Node
+          instance
+
+        - For 'type: phandles', 'val' is a list of the pointed-to Node
+          instances
+
+        - For 'type: phandle-array', 'val' is a list of ControllerAndData
+          instances. See the documentation for that class.
+
+    val_as_token:
+      The value of the property as a token, i.e. with non-alphanumeric
+      characters replaced with underscores. This is only safe to access
+      if self.enum_tokenizable returns True.
+
+    enum_index:
+      The index of 'val' in 'spec.enum' (which comes from the 'enum:' list
+      in the binding), or None if spec.enum is None.
+    """
+
+    def __init__(self, spec, val, node):
+        self.val = val
+        self.spec = spec
+        self.node = node
+
+    @property
+    def name(self):
+        "See the class docstring"
+        return self.spec.name
+
+    @property
+    def description(self):
+        "See the class docstring"
+        return self.spec.description.strip()
+
+    @property
+    def type(self):
+        "See the class docstring"
+        return self.spec.type
+
+    @property
+    def val_as_token(self):
+        "See the class docstring"
+        return re.sub(_NOT_ALPHANUM_OR_UNDERSCORE, '_', self.val)
+
+    @property
+    def enum_index(self):
+        "See the class docstring"
+        enum = self.spec.enum
+        return enum.index(self.val) if enum else None
+
+    def __repr__(self):
+        fields = ["name: " + self.name,
+                  # repr() to deal with lists
+                  "type: " + self.type,
+                  "value: " + repr(self.val)]
+
+        if self.enum_index is not None:
+            fields.append("enum index: {}".format(self.enum_index))
+
+        return "<Property, {}>".format(", ".join(fields))
+
+
+class Binding:
+    """
+    Represents a parsed binding.
+
+    These attributes are available on Binding objects:
+
+    path:
+      The absolute path to the file defining the binding.
+
+    description:
+      The free-form description of the binding.
+
+    compatible:
+      The compatible string the binding matches.
+
+      This may be None. For example, it's None when the Binding is inferred
+      from node properties. It can also be None for Binding objects created
+      using 'child-binding:' with no compatible.
+
+    prop2specs:
+      A collections.OrderedDict mapping property names to PropertySpec objects
+      describing those properties' values.
+
+    specifier2cells:
+      A collections.OrderedDict that maps specifier space names (like "gpio",
+      "clock", "pwm", etc.) to lists of cell names.
+
+      For example, if the binding YAML contains 'pin' and 'flags' cell names
+      for the 'gpio' specifier space, like this:
+
+          gpio-cells:
+          - pin
+          - flags
+
+      Then the Binding object will have a 'specifier2cells' attribute mapping
+      "gpio" to ["pin", "flags"]. A missing key should be interpreted as zero
+      cells.
+
+    raw:
+      The binding as an object parsed from YAML.
+
+    bus:
+      If nodes with this binding's 'compatible' describe a bus, a string
+      describing the bus type (like "i2c"). None otherwise.
+
+    on_bus:
+      If nodes with this binding's 'compatible' appear on a bus, a string
+      describing the bus type (like "i2c"). None otherwise.
+
+    child_binding:
+      If this binding describes the properties of child nodes, then
+      this is a Binding object for those children; it is None otherwise.
+      A Binding object's 'child_binding.child_binding' is not None if there
+      are multiple levels of 'child-binding' descriptions in the binding.
+    """
+
+    def __init__(self, path, fname2path, raw=None,
+                 require_compatible=True, require_description=True):
+        """
+        Binding constructor.
+
+        path:
+          Path to binding YAML file. May be None.
+
+        fname2path:
+          Map from include files to their absolute paths. Must
+          not be None, but may be empty.
+
+        raw:
+          Optional raw content in the binding.
+          This does not have to have any "include:" lines resolved.
+          May be left out, in which case 'path' is opened and read.
+          This can be used to resolve child bindings, for example.
+
+        require_compatible:
+          If True, it is an error if the binding does not contain a
+          "compatible:" line. If False, a missing "compatible:" is
+          not an error. Either way, "compatible:" must be a string
+          if it is present in the binding.
+
+        require_description:
+          If True, it is an error if the binding does not contain a
+          "description:" line. If False, a missing "description:" is
+          not an error. Either way, "description:" must be a string
+          if it is present in the binding.
+        """
+        self.path = path
+        self._fname2path = fname2path
+
+        if raw is None:
+            with open(path, encoding="utf-8") as f:
+                raw = yaml.load(f, Loader=_BindingLoader)
+
+        # Merge any included files into self.raw. This also pulls in
+        # inherited child binding definitions, so it has to be done
+        # before initializing those.
+        self.raw = self._merge_includes(raw, self.path)
+
+        # Recursively initialize any child bindings. These don't
+        # require a 'compatible' or 'description' to be well defined,
+        # but they must be dicts.
+        if "child-binding" in raw:
+            if not isinstance(raw["child-binding"], dict):
+                _err(f"malformed 'child-binding:' in {self.path}, "
+                     "expected a binding (dictionary with keys/values)")
+            self.child_binding = Binding(path, fname2path,
+                                         raw=raw["child-binding"],
+                                         require_compatible=False,
+                                         require_description=False)
+        else:
+            self.child_binding = None
+
+        # Make sure this is a well defined object.
+        self._check(require_compatible, require_description)
+
+        # Initialize look up tables.
+        self.prop2specs = OrderedDict()
+        for prop_name in self.raw.get("properties", {}).keys():
+            self.prop2specs[prop_name] = PropertySpec(prop_name, self)
+        self.specifier2cells = OrderedDict()
+        for key, val in self.raw.items():
+            if key.endswith("-cells"):
+                self.specifier2cells[key[:-len("-cells")]] = val
+
+    def __repr__(self):
+        if self.compatible:
+            compat = f" for compatible '{self.compatible}'"
+        else:
+            compat = ""
+        return f"<Binding {os.path.basename(self.path)}" + compat + ">"
+
+    @property
+    def description(self):
+        "See the class docstring"
+        return self.raw['description']
+
+    @property
+    def compatible(self):
+        "See the class docstring"
+        return self.raw.get('compatible')
+
+    @property
+    def bus(self):
+        "See the class docstring"
+        return self.raw.get('bus')
+
+    @property
+    def on_bus(self):
+        "See the class docstring"
+        return self.raw.get('on-bus')
+
+    def _merge_includes(self, raw, binding_path):
+        # Constructor helper. Merges included files in
+        # 'raw["include"]' into 'raw' using 'self._include_paths' as a
+        # source of include files, removing the "include" key while
+        # doing so.
+        #
+        # This treats 'binding_path' as the binding file being built up
+        # and uses it for error messages.
+
+        if "include" not in raw:
+            return raw
+
+        include = raw.pop("include")
+
+        # First, merge the included files together. If more than one included
+        # file has a 'required:' for a particular property, OR the values
+        # together, so that 'required: true' wins.
+
+        merged = {}
+
+        if isinstance(include, str):
+            # Simple scalar string case
+            _merge_props(merged, self._load_raw(include), None, binding_path,
+                         False)
+        elif isinstance(include, list):
+            # List of strings and maps. These types may be intermixed.
+            for elem in include:
+                if isinstance(elem, str):
+                    _merge_props(merged, self._load_raw(elem), None,
+                                 binding_path, False)
+                elif isinstance(elem, dict):
+                    name = elem.pop('name', None)
+                    allowlist = elem.pop('property-allowlist', None)
+                    blocklist = elem.pop('property-blocklist', None)
+                    child_filter = elem.pop('child-binding', None)
+
+                    if elem:
+                        # We've popped out all the valid keys.
+                        _err(f"'include:' in {binding_path} should not have "
+                             f"these unexpected contents: {elem}")
+
+                    _check_include_dict(name, allowlist, blocklist,
+                                        child_filter, binding_path)
+
+                    contents = self._load_raw(name)
+
+                    _filter_properties(contents, allowlist, blocklist,
+                                       child_filter, binding_path)
+                    _merge_props(merged, contents, None, binding_path, False)
+                else:
+                    _err(f"all elements in 'include:' in {binding_path} "
+                         "should be either strings or maps with a 'name' key "
+                         "and optional 'property-allowlist' or "
+                         f"'property-blocklist' keys, but got: {elem}")
+        else:
+            # Invalid item.
+            _err(f"'include:' in {binding_path} "
+                 f"should be a string or list, but has type {type(include)}")
+
+        # Next, merge the merged included files into 'raw'. Error out if
+        # 'raw' has 'required: false' while the merged included files have
+        # 'required: true'.
+
+        _merge_props(raw, merged, None, binding_path, check_required=True)
+
+        return raw
+
+    def _load_raw(self, fname):
+        # Returns the contents of the binding given by 'fname' after merging
+        # any bindings it lists in 'include:' into it. 'fname' is just the
+        # basename of the file, so we check that there aren't multiple
+        # candidates.
+
+        path = self._fname2path.get(fname)
+
+        if not path:
+            _err(f"'{fname}' not found")
+
+        with open(path, encoding="utf-8") as f:
+            contents = yaml.load(f, Loader=_BindingLoader)
+
+        return self._merge_includes(contents, path)
+
+    def _check(self, require_compatible, require_description):
+        # Does sanity checking on the binding.
+
+        raw = self.raw
+
+        if "compatible" in raw:
+            compatible = raw["compatible"]
+            if not isinstance(compatible, str):
+                _err(f"malformed 'compatible: {compatible}' "
+                     f"field in {self.path} - "
+                     f"should be a string, not {type(compatible).__name__}")
+        elif require_compatible:
+            _err(f"missing 'compatible' in {self.path}")
+
+        if "description" in raw:
+            description = raw["description"]
+            if not isinstance(description, str) or not description:
+                _err(f"malformed or empty 'description' in {self.path}")
+        elif require_description:
+            _err(f"missing 'description' in {self.path}")
+
+        # Allowed top-level keys. The 'include' key should have been
+        # removed by _load_raw() already.
+        ok_top = {"description", "compatible", "bus", "on-bus",
+                  "properties", "child-binding"}
+
+        # Descriptive errors for legacy bindings.
+        legacy_errors = {
+            "#cells": "expected *-cells syntax",
+            "child": "use 'bus: <bus>' instead",
+            "child-bus": "use 'bus: <bus>' instead",
+            "parent": "use 'on-bus: <bus>' instead",
+            "parent-bus": "use 'on-bus: <bus>' instead",
+            "sub-node": "use 'child-binding' instead",
+            "title": "use 'description' instead",
+        }
+
+        for key in raw:
+            if key in legacy_errors:
+                _err(f"legacy '{key}:' in {self.path}, {legacy_errors[key]}")
+
+            if key not in ok_top and not key.endswith("-cells"):
+                _err(f"unknown key '{key}' in {self.path}, "
+                     "expected one of {', '.join(ok_top)}, or *-cells")
+
+        for bus_key in "bus", "on-bus":
+            if bus_key in raw and \
+               not isinstance(raw[bus_key], str):
+                _err(f"malformed '{bus_key}:' value in {self.path}, "
+                     "expected string")
+
+        self._check_properties()
+
+        for key, val in raw.items():
+            if key.endswith("-cells"):
+                if not isinstance(val, list) or \
+                   not all(isinstance(elem, str) for elem in val):
+                    _err(f"malformed '{key}:' in {self.path}, "
+                         "expected a list of strings")
+
+    def _check_properties(self):
+        # _check() helper for checking the contents of 'properties:'.
+
+        raw = self.raw
+
+        if "properties" not in raw:
+            return
+
+        ok_prop_keys = {"description", "type", "required",
+                        "enum", "const", "default", "deprecated"}
+
+        for prop_name, options in raw["properties"].items():
+            for key in options:
+                if key not in ok_prop_keys:
+                    _err(f"unknown setting '{key}' in "
+                         f"'properties: {prop_name}: ...' in {self.path}, "
+                         f"expected one of {', '.join(ok_prop_keys)}")
+
+            _check_prop_type_and_default(
+                prop_name, options.get("type"),
+                options.get("default"),
+                self.path)
+
+            for true_false_opt in ["required", "deprecated"]:
+                if true_false_opt in options:
+                    option = options[true_false_opt]
+                    if not isinstance(option, bool):
+                        _err(f"malformed '{true_false_opt}:' setting '{option}' "
+                             f"for '{prop_name}' in 'properties' in {self.path}, "
+                             "expected true/false")
+
+            if options.get("deprecated") and options.get("required"):
+                _err(f"'{prop_name}' in 'properties' in {self.path} should not "
+                      "have both 'deprecated' and 'required' set")
+
+            if "description" in options and \
+               not isinstance(options["description"], str):
+                _err("missing, malformed, or empty 'description' for "
+                     f"'{prop_name}' in 'properties' in {self.path}")
+
+            if "enum" in options and not isinstance(options["enum"], list):
+                _err(f"enum in {self.path} for property '{prop_name}' "
+                     "is not a list")
+
+            if "const" in options and not isinstance(options["const"],
+                                                     (int, str)):
+                _err(f"const in {self.path} for property '{prop_name}' "
+                     "is not a scalar")
+
+
+def bindings_from_paths(yaml_paths, ignore_errors=False):
+    """
+    Get a list of Binding objects from the yaml files 'yaml_paths'.
+
+    If 'ignore_errors' is True, YAML files that cause an EDTError when
+    loaded are ignored. (No other exception types are silenced.)
+    """
+
+    ret = []
+    fname2path = {os.path.basename(path): path for path in yaml_paths}
+    for path in yaml_paths:
+        try:
+            ret.append(Binding(path, fname2path))
+        except EDTError:
+            if ignore_errors:
+                continue
+            raise
+
+    return ret
+
+class PropertySpec:
+    """
+    Represents a "property specification", i.e. the description of a
+    property provided by a binding file, like its type and description.
+
+    These attributes are available on PropertySpec objects:
+
+    binding:
+      The Binding object which defined this property.
+
+    name:
+      The property's name.
+
+    path:
+      The file where this property was defined. In case a binding includes
+      other bindings, this is the file where the property was last modified.
+
+    type:
+      The type of the property as a string, as given in the binding.
+
+    description:
+      The free-form description of the property as a string, or None.
+
+    enum:
+      A list of values the property may take as given in the binding, or None.
+
+    enum_tokenizable:
+      True if enum is not None and all the values in it are tokenizable;
+      False otherwise.
+
+      A property must have string type and an "enum:" in its binding to be
+      tokenizable. Additionally, the "enum:" values must be unique after
+      converting all non-alphanumeric characters to underscores (so "foo bar"
+      and "foo_bar" in the same "enum:" would not be tokenizable).
+
+    enum_upper_tokenizable:
+      Like 'enum_tokenizable', with the additional restriction that the
+      "enum:" values must be unique after uppercasing and converting
+      non-alphanumeric characters to underscores.
+
+    const:
+      The property's constant value as given in the binding, or None.
+
+    default:
+      The property's default value as given in the binding, or None.
+
+    deprecated:
+      True if the property is deprecated; False otherwise.
+
+    required:
+      True if the property is marked required; False otherwise.
+    """
+
+    def __init__(self, name, binding):
+        self.binding = binding
+        self.name = name
+        self._raw = self.binding.raw["properties"][name]
+
+    def __repr__(self):
+        return f"<PropertySpec {self.name} type '{self.type}'>"
+
+    @property
+    def path(self):
+        "See the class docstring"
+        return self.binding.path
+
+    @property
+    def type(self):
+        "See the class docstring"
+        return self._raw["type"]
+
+    @property
+    def description(self):
+        "See the class docstring"
+        return self._raw.get("description")
+
+    @property
+    def enum(self):
+        "See the class docstring"
+        return self._raw.get("enum")
+
+    @property
+    def enum_tokenizable(self):
+        "See the class docstring"
+        if not hasattr(self, '_enum_tokenizable'):
+            if self.type != 'string' or self.enum is None:
+                self._enum_tokenizable = False
+            else:
+                # Saving _as_tokens here lets us reuse it in
+                # enum_upper_tokenizable.
+                self._as_tokens = [re.sub(_NOT_ALPHANUM_OR_UNDERSCORE,
+                                          '_', value)
+                                   for value in self.enum]
+                self._enum_tokenizable = (len(self._as_tokens) ==
+                                          len(set(self._as_tokens)))
+
+        return self._enum_tokenizable
+
+    @property
+    def enum_upper_tokenizable(self):
+        "See the class docstring"
+        if not hasattr(self, '_enum_upper_tokenizable'):
+            if not self.enum_tokenizable:
+                self._enum_upper_tokenizable = False
+            else:
+                self._enum_upper_tokenizable = \
+                    (len(self._as_tokens) ==
+                     len(set(x.upper() for x in self._as_tokens)))
+        return self._enum_upper_tokenizable
+
+    @property
+    def const(self):
+        "See the class docstring"
+        return self._raw.get("const")
+
+    @property
+    def default(self):
+        "See the class docstring"
+        return self._raw.get("default")
+
+    @property
+    def required(self):
+        "See the class docstring"
+        return self._raw.get("required", False)
+
+    @property
+    def deprecated(self):
+        "See the class docstring"
+        return self._raw.get("deprecated", False)
+
+class EDTError(Exception):
+    "Exception raised for devicetree- and binding-related errors"
+
+#
+# Public global functions
+#
+
+
+def load_vendor_prefixes_txt(vendor_prefixes):
+    """Load a vendor-prefixes.txt file and return a dict
+    representation mapping a vendor prefix to the vendor name.
+    """
+    vnd2vendor = {}
+    with open(vendor_prefixes, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+
+            if not line or line.startswith('#'):
+                # Comment or empty line.
+                continue
+
+            # Other lines should be in this form:
+            #
+            # <vnd><TAB><vendor>
+            vnd_vendor = line.split('\t', 1)
+            assert len(vnd_vendor) == 2, line
+            vnd2vendor[vnd_vendor[0]] = vnd_vendor[1]
+    return vnd2vendor
+
+#
+# Private global functions
+#
+
+
+def _dt_compats(dt):
+    # Returns a set() with all 'compatible' strings in the devicetree
+    # represented by dt (a dtlib.DT instance)
+
+    return {compat
+            for node in dt.node_iter()
+                if "compatible" in node.props
+                    for compat in node.props["compatible"].to_strings()}
+
+
+def _binding_paths(bindings_dirs):
+    # Returns a list with the paths to all bindings (.yaml files) in
+    # 'bindings_dirs'
+
+    binding_paths = []
+
+    for bindings_dir in bindings_dirs:
+        for root, _, filenames in os.walk(bindings_dir):
+            for filename in filenames:
+                if filename.endswith(".yaml"):
+                    binding_paths.append(os.path.join(root, filename))
+
+    return binding_paths
+
+
+def _binding_inc_error(msg):
+    # Helper for reporting errors in the !include implementation
+
+    raise yaml.constructor.ConstructorError(None, None, "error: " + msg)
+
+
+def _check_include_dict(name, allowlist, blocklist, child_filter,
+                        binding_path):
+    # Check that an 'include:' named 'name' with property-allowlist
+    # 'allowlist', property-blocklist 'blocklist', and
+    # child-binding filter 'child_filter' has valid structure.
+
+    if name is None:
+        _err(f"'include:' element in {binding_path} "
+             "should have a 'name' key")
+
+    if allowlist is not None and blocklist is not None:
+        _err(f"'include:' of file '{name}' in {binding_path} "
+             "should not specify both 'property-allowlist:' "
+             "and 'property-blocklist:'")
+
+    while child_filter is not None:
+        child_copy = deepcopy(child_filter)
+        child_allowlist = child_copy.pop('property-allowlist', None)
+        child_blocklist = child_copy.pop('property-blocklist', None)
+        next_child_filter = child_copy.pop('child-binding', None)
+
+        if child_copy:
+            # We've popped out all the valid keys.
+            _err(f"'include:' of file '{name}' in {binding_path} "
+                 "should not have these unexpected contents in a "
+                 f"'child-binding': {child_copy}")
+
+        if child_allowlist is not None and child_blocklist is not None:
+            _err(f"'include:' of file '{name}' in {binding_path} "
+                 "should not specify both 'property-allowlist:' and "
+                 "'property-blocklist:' in a 'child-binding:'")
+
+        child_filter = next_child_filter
+
+
+def _filter_properties(raw, allowlist, blocklist, child_filter,
+                       binding_path):
+    # Destructively modifies 'raw["properties"]' and
+    # 'raw["child-binding"]', if they exist, according to
+    # 'allowlist', 'blocklist', and 'child_filter'.
+
+    props = raw.get('properties')
+    _filter_properties_helper(props, allowlist, blocklist, binding_path)
+
+    child_binding = raw.get('child-binding')
+    while child_filter is not None and child_binding is not None:
+        _filter_properties_helper(child_binding.get('properties'),
+                                  child_filter.get('property-allowlist'),
+                                  child_filter.get('property-blocklist'),
+                                  binding_path)
+        child_filter = child_filter.get('child-binding')
+        child_binding = child_binding.get('child-binding')
+
+
+def _filter_properties_helper(props, allowlist, blocklist, binding_path):
+    if props is None or (allowlist is None and blocklist is None):
+        return
+
+    _check_prop_filter('property-allowlist', allowlist, binding_path)
+    _check_prop_filter('property-blocklist', blocklist, binding_path)
+
+    if allowlist is not None:
+        allowset = set(allowlist)
+        to_del = [prop for prop in props if prop not in allowset]
+    else:
+        blockset = set(blocklist)
+        to_del = [prop for prop in props if prop in blockset]
+
+    for prop in to_del:
+        del props[prop]
+
+
+def _check_prop_filter(name, value, binding_path):
+    # Ensure an include: ... property-allowlist or property-blocklist
+    # is a list.
+
+    if value is None:
+        return
+
+    if not isinstance(value, list):
+        _err(f"'{name}' value {value} in {binding_path} should be a list")
+
+
+def _merge_props(to_dict, from_dict, parent, binding_path, check_required):
+    # Recursively merges 'from_dict' into 'to_dict', to implement 'include:'.
+    #
+    # If 'from_dict' and 'to_dict' contain a 'required:' key for the same
+    # property, then the values are ORed together.
+    #
+    # If 'check_required' is True, then an error is raised if 'from_dict' has
+    # 'required: true' while 'to_dict' has 'required: false'. This prevents
+    # bindings from "downgrading" requirements from bindings they include,
+    # which might help keep bindings well-organized.
+    #
+    # It's an error for most other keys to appear in both 'from_dict' and
+    # 'to_dict'. When it's not an error, the value in 'to_dict' takes
+    # precedence.
+    #
+    # 'parent' is the name of the parent key containing 'to_dict' and
+    # 'from_dict', and 'binding_path' is the path to the top-level binding.
+    # These are used to generate errors for sketchy property overwrites.
+
+    for prop in from_dict:
+        if isinstance(to_dict.get(prop), dict) and \
+           isinstance(from_dict[prop], dict):
+            _merge_props(to_dict[prop], from_dict[prop], prop, binding_path,
+                         check_required)
+        elif prop not in to_dict:
+            to_dict[prop] = from_dict[prop]
+        elif _bad_overwrite(to_dict, from_dict, prop, check_required):
+            _err("{} (in '{}'): '{}' from included file overwritten "
+                 "('{}' replaced with '{}')".format(
+                     binding_path, parent, prop, from_dict[prop],
+                     to_dict[prop]))
+        elif prop == "required":
+            # Need a separate check here, because this code runs before
+            # Binding._check()
+            if not (isinstance(from_dict["required"], bool) and
+                    isinstance(to_dict["required"], bool)):
+                _err("malformed 'required:' setting for '{}' in 'properties' "
+                     "in {}, expected true/false".format(parent, binding_path))
+
+            # 'required: true' takes precedence
+            to_dict["required"] = to_dict["required"] or from_dict["required"]
+
+
+def _bad_overwrite(to_dict, from_dict, prop, check_required):
+    # _merge_props() helper. Returns True in cases where it's bad that
+    # to_dict[prop] takes precedence over from_dict[prop].
+
+    if to_dict[prop] == from_dict[prop]:
+        return False
+
+    # These are overridden deliberately
+    if prop in {"title", "description", "compatible"}:
+        return False
+
+    if prop == "required":
+        if not check_required:
+            return False
+        return from_dict[prop] and not to_dict[prop]
+
+    return True
+
+
+def _binding_include(loader, node):
+    # Implements !include, for backwards compatibility. '!include [foo, bar]'
+    # just becomes [foo, bar].
+
+    if isinstance(node, yaml.ScalarNode):
+        # !include foo.yaml
+        return [loader.construct_scalar(node)]
+
+    if isinstance(node, yaml.SequenceNode):
+        # !include [foo.yaml, bar.yaml]
+        return loader.construct_sequence(node)
+
+    _binding_inc_error("unrecognised node type in !include statement")
+
+
+def _check_prop_type_and_default(prop_name, prop_type, default, binding_path):
+    # Binding._check_properties() helper. Checks 'type:' and 'default:' for the
+    # property named 'prop_name'
+
+    if prop_type is None:
+        _err("missing 'type:' for '{}' in 'properties' in {}"
+             .format(prop_name, binding_path))
+
+    ok_types = {"boolean", "int", "array", "uint8-array", "string",
+                "string-array", "phandle", "phandles", "phandle-array",
+                "path", "compound"}
+
+    if prop_type not in ok_types:
+        _err("'{}' in 'properties:' in {} has unknown type '{}', expected one "
+             "of {}".format(prop_name, binding_path, prop_type,
+                            ", ".join(ok_types)))
+
+    if prop_type == "phandle-array" and not prop_name.endswith("s"):
+        _err("'{}' in 'properties:' in {} is 'type: phandle-array', but its "
+             "name does not end in -s. This is required since property names "
+             "like '#pwm-cells' and 'pwm-names' get derived from 'pwms', for "
+             "example.".format(prop_name, binding_path))
+
+    # Check default
+
+    if default is None:
+        return
+
+    if prop_type in {"boolean", "compound", "phandle", "phandles",
+                     "phandle-array", "path"}:
+        _err("'default:' can't be combined with 'type: {}' for '{}' in "
+             "'properties:' in {}".format(prop_type, prop_name, binding_path))
+
+    def ok_default():
+        # Returns True if 'default' is an okay default for the property's type
+
+        if prop_type == "int" and isinstance(default, int) or \
+           prop_type == "string" and isinstance(default, str):
+            return True
+
+        # array, uint8-array, or string-array
+
+        if not isinstance(default, list):
+            return False
+
+        if prop_type == "array" and \
+           all(isinstance(val, int) for val in default):
+            return True
+
+        if prop_type == "uint8-array" and \
+           all(isinstance(val, int) and 0 <= val <= 255 for val in default):
+            return True
+
+        # string-array
+        return all(isinstance(val, str) for val in default)
+
+    if not ok_default():
+        _err("'default: {}' is invalid for '{}' in 'properties:' in {}, which "
+             "has type {}".format(default, prop_name, binding_path, prop_type))
+
+
+def _translate(addr, node):
+    # Recursively translates 'addr' on 'node' to the address space(s) of its
+    # parent(s), by looking at 'ranges' properties. Returns the translated
+    # address.
+    #
+    # node:
+    #   dtlib.Node instance
+
+    if not node.parent or "ranges" not in node.parent.props:
+        # No translation
+        return addr
+
+    if not node.parent.props["ranges"].value:
+        # DT spec.: "If the property is defined with an <empty> value, it
+        # specifies that the parent and child address space is identical, and
+        # no address translation is required."
+        #
+        # Treat this the same as a 'range' that explicitly does a one-to-one
+        # mapping, as opposed to there not being any translation.
+        return _translate(addr, node.parent)
+
+    # Gives the size of each component in a translation 3-tuple in 'ranges'
+    child_address_cells = _address_cells(node)
+    parent_address_cells = _address_cells(node.parent)
+    child_size_cells = _size_cells(node)
+
+    # Number of cells for one translation 3-tuple in 'ranges'
+    entry_cells = child_address_cells + parent_address_cells + child_size_cells
+
+    for raw_range in _slice(node.parent, "ranges", 4*entry_cells,
+                            "4*(<#address-cells> (= {}) + "
+                            "<#address-cells for parent> (= {}) + "
+                            "<#size-cells> (= {}))"
+                            .format(child_address_cells, parent_address_cells,
+                                    child_size_cells)):
+        child_addr = to_num(raw_range[:4*child_address_cells])
+        raw_range = raw_range[4*child_address_cells:]
+
+        parent_addr = to_num(raw_range[:4*parent_address_cells])
+        raw_range = raw_range[4*parent_address_cells:]
+
+        child_len = to_num(raw_range)
+
+        if child_addr <= addr < child_addr + child_len:
+            # 'addr' is within range of a translation in 'ranges'. Recursively
+            # translate it and return the result.
+            return _translate(parent_addr + addr - child_addr, node.parent)
+
+    # 'addr' is not within range of any translation in 'ranges'
+    return addr
+
+
+def _add_names(node, names_ident, objs):
+    # Helper for registering names from <foo>-names properties.
+    #
+    # node:
+    #   edtlib.Node instance
+    #
+    # names-ident:
+    #   The <foo> part of <foo>-names, e.g. "reg" for "reg-names"
+    #
+    # objs:
+    #   list of objects whose .name field should be set
+
+    full_names_ident = names_ident + "-names"
+
+    if full_names_ident in node.props:
+        names = node.props[full_names_ident].to_strings()
+        if len(names) != len(objs):
+            _err("{} property in {} in {} has {} strings, expected {} strings"
+                 .format(full_names_ident, node.path, node.dt.filename,
+                         len(names), len(objs)))
+
+        for obj, name in zip(objs, names):
+            if obj is None:
+                continue
+            obj.name = name
+    else:
+        for obj in objs:
+            if obj is not None:
+                obj.name = None
+
+
+def _interrupt_parent(node):
+    # Returns the node pointed at by the closest 'interrupt-parent', searching
+    # the parents of 'node'. As of writing, this behavior isn't specified in
+    # the DT spec., but seems to match what some .dts files except.
+
+    while node:
+        if "interrupt-parent" in node.props:
+            return node.props["interrupt-parent"].to_node()
+        node = node.parent
+
+    _err("{!r} has an 'interrupts' property, but neither the node nor any "
+         "of its parents has an 'interrupt-parent' property".format(node))
+
+
+def _interrupts(node):
+    # Returns a list of (<controller>, <data>) tuples, with one tuple per
+    # interrupt generated by 'node'. <controller> is the destination of the
+    # interrupt (possibly after mapping through an 'interrupt-map'), and <data>
+    # the data associated with the interrupt (as a 'bytes' object).
+
+    # Takes precedence over 'interrupts' if both are present
+    if "interrupts-extended" in node.props:
+        prop = node.props["interrupts-extended"]
+        return [_map_interrupt(node, iparent, spec)
+                for iparent, spec in _phandle_val_list(prop, "interrupt")]
+
+    if "interrupts" in node.props:
+        # Treat 'interrupts' as a special case of 'interrupts-extended', with
+        # the same interrupt parent for all interrupts
+
+        iparent = _interrupt_parent(node)
+        interrupt_cells = _interrupt_cells(iparent)
+
+        return [_map_interrupt(node, iparent, raw)
+                for raw in _slice(node, "interrupts", 4*interrupt_cells,
+                                  "4*<#interrupt-cells>")]
+
+    return []
+
+
+def _map_interrupt(child, parent, child_spec):
+    # Translates an interrupt headed from 'child' to 'parent' with data
+    # 'child_spec' through any 'interrupt-map' properties. Returns a
+    # (<controller>, <data>) tuple with the final destination after mapping.
+
+    if "interrupt-controller" in parent.props:
+        return (parent, child_spec)
+
+    def own_address_cells(node):
+        # Used for parents pointed at by 'interrupt-map'. We can't use
+        # _address_cells(), because it's the #address-cells property on 'node'
+        # itself that matters.
+
+        address_cells = node.props.get("#address-cells")
+        if not address_cells:
+            _err("missing #address-cells on {!r} (while handling interrupt-map)"
+                 .format(node))
+        return address_cells.to_num()
+
+    def spec_len_fn(node):
+        # Can't use _address_cells() here, because it's the #address-cells
+        # property on 'node' itself that matters
+        return own_address_cells(node) + _interrupt_cells(node)
+
+    parent, raw_spec = _map(
+        "interrupt", child, parent, _raw_unit_addr(child) + child_spec,
+        spec_len_fn, require_controller=True)
+
+    # Strip the parent unit address part, if any
+    return (parent, raw_spec[4*own_address_cells(parent):])
+
+
+def _map_phandle_array_entry(child, parent, child_spec, basename):
+    # Returns a (<controller>, <data>) tuple with the final destination after
+    # mapping through any '<basename>-map' (e.g. gpio-map) properties. See
+    # _map_interrupt().
+
+    def spec_len_fn(node):
+        prop_name = "#{}-cells".format(basename)
+        if prop_name not in node.props:
+            _err("expected '{}' property on {!r} (referenced by {!r})"
+                 .format(prop_name, node, child))
+        return node.props[prop_name].to_num()
+
+    # Do not require <prefix>-controller for anything but interrupts for now
+    return _map(basename, child, parent, child_spec, spec_len_fn,
+                require_controller=False)
+
+
+def _map(prefix, child, parent, child_spec, spec_len_fn, require_controller):
+    # Common code for mapping through <prefix>-map properties, e.g.
+    # interrupt-map and gpio-map.
+    #
+    # prefix:
+    #   The prefix, e.g. "interrupt" or "gpio"
+    #
+    # child:
+    #   The "sender", e.g. the node with 'interrupts = <...>'
+    #
+    # parent:
+    #   The "receiver", e.g. a node with 'interrupt-map = <...>' or
+    #   'interrupt-controller' (no mapping)
+    #
+    # child_spec:
+    #   The data associated with the interrupt/GPIO/etc., as a 'bytes' object,
+    #   e.g. <1 2> for 'foo-gpios = <&gpio1 1 2>'.
+    #
+    # spec_len_fn:
+    #   Function called on a parent specified in a *-map property to get the
+    #   length of the parent specifier (data after phandle in *-map), in cells
+    #
+    # require_controller:
+    #   If True, the final controller node after mapping is required to have
+    #   to have a <prefix>-controller property.
+
+    map_prop = parent.props.get(prefix + "-map")
+    if not map_prop:
+        if require_controller and prefix + "-controller" not in parent.props:
+            _err("expected '{}-controller' property on {!r} "
+                 "(referenced by {!r})".format(prefix, parent, child))
+
+        # No mapping
+        return (parent, child_spec)
+
+    masked_child_spec = _mask(prefix, child, parent, child_spec)
+
+    raw = map_prop.value
+    while raw:
+        if len(raw) < len(child_spec):
+            _err("bad value for {!r}, missing/truncated child data"
+                 .format(map_prop))
+        child_spec_entry = raw[:len(child_spec)]
+        raw = raw[len(child_spec):]
+
+        if len(raw) < 4:
+            _err("bad value for {!r}, missing/truncated phandle"
+                 .format(map_prop))
+        phandle = to_num(raw[:4])
+        raw = raw[4:]
+
+        # Parent specified in *-map
+        map_parent = parent.dt.phandle2node.get(phandle)
+        if not map_parent:
+            _err("bad phandle ({}) in {!r}".format(phandle, map_prop))
+
+        map_parent_spec_len = 4*spec_len_fn(map_parent)
+        if len(raw) < map_parent_spec_len:
+            _err("bad value for {!r}, missing/truncated parent data"
+                 .format(map_prop))
+        parent_spec = raw[:map_parent_spec_len]
+        raw = raw[map_parent_spec_len:]
+
+        # Got one *-map row. Check if it matches the child data.
+        if child_spec_entry == masked_child_spec:
+            # Handle *-map-pass-thru
+            parent_spec = _pass_thru(
+                prefix, child, parent, child_spec, parent_spec)
+
+            # Found match. Recursively map and return it.
+            return _map(prefix, parent, map_parent, parent_spec, spec_len_fn,
+                        require_controller)
+
+    _err("child specifier for {!r} ({}) does not appear in {!r}"
+         .format(child, child_spec, map_prop))
+
+
+def _mask(prefix, child, parent, child_spec):
+    # Common code for handling <prefix>-mask properties, e.g. interrupt-mask.
+    # See _map() for the parameters.
+
+    mask_prop = parent.props.get(prefix + "-map-mask")
+    if not mask_prop:
+        # No mask
+        return child_spec
+
+    mask = mask_prop.value
+    if len(mask) != len(child_spec):
+        _err("{!r}: expected '{}-mask' in {!r} to be {} bytes, is {} bytes"
+             .format(child, prefix, parent, len(child_spec), len(mask)))
+
+    return _and(child_spec, mask)
+
+
+def _pass_thru(prefix, child, parent, child_spec, parent_spec):
+    # Common code for handling <prefix>-map-thru properties, e.g.
+    # interrupt-pass-thru.
+    #
+    # parent_spec:
+    #   The parent data from the matched entry in the <prefix>-map property
+    #
+    # See _map() for the other parameters.
+
+    pass_thru_prop = parent.props.get(prefix + "-map-pass-thru")
+    if not pass_thru_prop:
+        # No pass-thru
+        return parent_spec
+
+    pass_thru = pass_thru_prop.value
+    if len(pass_thru) != len(child_spec):
+        _err("{!r}: expected '{}-map-pass-thru' in {!r} to be {} bytes, is {} bytes"
+             .format(child, prefix, parent, len(child_spec), len(pass_thru)))
+
+    res = _or(_and(child_spec, pass_thru),
+              _and(parent_spec, _not(pass_thru)))
+
+    # Truncate to length of parent spec.
+    return res[-len(parent_spec):]
+
+
+def _raw_unit_addr(node):
+    # _map_interrupt() helper. Returns the unit address (derived from 'reg' and
+    # #address-cells) as a raw 'bytes'
+
+    if 'reg' not in node.props:
+        _err("{!r} lacks 'reg' property (needed for 'interrupt-map' unit "
+             "address lookup)".format(node))
+
+    addr_len = 4*_address_cells(node)
+
+    if len(node.props['reg'].value) < addr_len:
+        _err("{!r} has too short 'reg' property (while doing 'interrupt-map' "
+             "unit address lookup)".format(node))
+
+    return node.props['reg'].value[:addr_len]
+
+
+def _and(b1, b2):
+    # Returns the bitwise AND of the two 'bytes' objects b1 and b2. Pads
+    # with ones on the left if the lengths are not equal.
+
+    # Pad on the left, to equal length
+    maxlen = max(len(b1), len(b2))
+    return bytes(x & y for x, y in zip(b1.rjust(maxlen, b'\xff'),
+                                       b2.rjust(maxlen, b'\xff')))
+
+
+def _or(b1, b2):
+    # Returns the bitwise OR of the two 'bytes' objects b1 and b2. Pads with
+    # zeros on the left if the lengths are not equal.
+
+    # Pad on the left, to equal length
+    maxlen = max(len(b1), len(b2))
+    return bytes(x | y for x, y in zip(b1.rjust(maxlen, b'\x00'),
+                                       b2.rjust(maxlen, b'\x00')))
+
+
+def _not(b):
+    # Returns the bitwise not of the 'bytes' object 'b'
+
+    # ANDing with 0xFF avoids negative numbers
+    return bytes(~x & 0xFF for x in b)
+
+
+def _phandle_val_list(prop, n_cells_name):
+    # Parses a '<phandle> <value> <phandle> <value> ...' value. The number of
+    # cells that make up each <value> is derived from the node pointed at by
+    # the preceding <phandle>.
+    #
+    # prop:
+    #   dtlib.Property with value to parse
+    #
+    # n_cells_name:
+    #   The <name> part of the #<name>-cells property to look for on the nodes
+    #   the phandles point to, e.g. "gpio" for #gpio-cells.
+    #
+    # Returns a list[Optional[tuple]].
+    #
+    # Each tuple in the list is a (<node>, <value>) pair, where <node>
+    # is the node pointed at by <phandle>. If <phandle> does not refer
+    # to a node, the entire list element is None.
+
+    full_n_cells_name = "#{}-cells".format(n_cells_name)
+
+    res = []
+
+    raw = prop.value
+    while raw:
+        if len(raw) < 4:
+            # Not enough room for phandle
+            _err("bad value for " + repr(prop))
+        phandle = to_num(raw[:4])
+        raw = raw[4:]
+
+        node = prop.node.dt.phandle2node.get(phandle)
+        if not node:
+            # Unspecified phandle-array element. This is valid; a 0
+            # phandle value followed by no cells is an empty element.
+            res.append(None)
+            continue
+
+        if full_n_cells_name not in node.props:
+            _err("{!r} lacks {}".format(node, full_n_cells_name))
+
+        n_cells = node.props[full_n_cells_name].to_num()
+        if len(raw) < 4*n_cells:
+            _err("missing data after phandle in " + repr(prop))
+
+        res.append((node, raw[:4*n_cells]))
+        raw = raw[4*n_cells:]
+
+    return res
+
+
+def _address_cells(node):
+    # Returns the #address-cells setting for 'node', giving the number of <u32>
+    # cells used to encode the address in the 'reg' property
+
+    if "#address-cells" in node.parent.props:
+        return node.parent.props["#address-cells"].to_num()
+    return 2  # Default value per DT spec.
+
+
+def _size_cells(node):
+    # Returns the #size-cells setting for 'node', giving the number of <u32>
+    # cells used to encode the size in the 'reg' property
+
+    if "#size-cells" in node.parent.props:
+        return node.parent.props["#size-cells"].to_num()
+    return 1  # Default value per DT spec.
+
+
+def _interrupt_cells(node):
+    # Returns the #interrupt-cells property value on 'node', erroring out if
+    # 'node' has no #interrupt-cells property
+
+    if "#interrupt-cells" not in node.props:
+        _err("{!r} lacks #interrupt-cells".format(node))
+    return node.props["#interrupt-cells"].to_num()
+
+
+def _slice(node, prop_name, size, size_hint):
+    # Splits node.props[prop_name].value into 'size'-sized chunks, returning a
+    # list of chunks. Raises EDTError if the length of the property is not
+    # evenly divisible by 'size'. 'size_hint' is a string shown on errors that
+    # gives a hint on how 'size' was calculated.
+
+    raw = node.props[prop_name].value
+    if len(raw) % size:
+        _err("'{}' property in {!r} has length {}, which is not evenly "
+             "divisible by {} (= {}). Note that #*-cells "
+             "properties come either from the parent node or from the "
+             "controller (in the case of 'interrupts')."
+             .format(prop_name, node, len(raw), size, size_hint))
+
+    return [raw[i:i + size] for i in range(0, len(raw), size)]
+
+
+def _check_dt(dt):
+    # Does devicetree sanity checks. dtlib is meant to be general and
+    # anything-goes except for very special properties like phandle, but in
+    # edtlib we can be pickier.
+
+    # Check that 'status' has one of the values given in the devicetree spec.
+
+    # Accept "ok" for backwards compatibility
+    ok_status = {"ok", "okay", "disabled", "reserved", "fail", "fail-sss"}
+
+    for node in dt.node_iter():
+        if "status" in node.props:
+            try:
+                status_val = node.props["status"].to_string()
+            except DTError as e:
+                # The error message gives the path
+                _err(str(e))
+
+            if status_val not in ok_status:
+                _err("unknown 'status' value \"{}\" in {} in {}, expected one "
+                     "of {} (see the devicetree specification)"
+                     .format(status_val, node.path, node.dt.filename,
+                             ", ".join(ok_status)))
+
+        ranges_prop = node.props.get("ranges")
+        if ranges_prop:
+            if ranges_prop.type not in (Type.EMPTY, Type.NUMS):
+                _err("expected 'ranges = < ... >;' in {} in {}, not '{}' "
+                     "(see the devicetree specification)"
+                     .format(node.path, node.dt.filename, ranges_prop))
+
+
+def _err(msg):
+    raise EDTError(msg)
+
+# Logging object
+_LOG = logging.getLogger(__name__)
+
+# Regular expression for non-alphanumeric-or-underscore characters.
+_NOT_ALPHANUM_OR_UNDERSCORE = re.compile(r'\W', re.ASCII)
+
+# Custom PyYAML binding loader class to avoid modifying yaml.Loader directly,
+# which could interfere with YAML loading in clients
+class _BindingLoader(Loader):
+    pass
+
+
+# Add legacy '!include foo.yaml' handling
+_BindingLoader.add_constructor("!include", _binding_include)
+
+# Use OrderedDict instead of plain dict for YAML mappings, to preserve
+# insertion order on Python 3.5 and earlier (plain dicts only preserve
+# insertion order on Python 3.6+). This makes testing easier and avoids
+# surprises.
+#
+# Adapted from
+# https://stackoverflow.com/questions/5121931/in-python-how-can-you-load-yaml-mappings-as-ordereddicts.
+# Hopefully this API stays stable.
+_BindingLoader.add_constructor(
+    yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG,
+    lambda loader, node: OrderedDict(loader.construct_pairs(node)))
+
+#
+# "Default" binding for properties which are defined by the spec.
+#
+# Zephyr: do not change the _DEFAULT_PROP_TYPES keys without
+# updating the documentation for the DT_PROP() macro in
+# include/devicetree.h.
+#
+
+_DEFAULT_PROP_TYPES = {
+    "compatible": "string-array",
+    "status": "string",
+    "reg": "array",
+    "reg-names": "string-array",
+    "label": "string",
+    "interrupts": "array",
+    "interrupts-extended": "compound",
+    "interrupt-names": "string-array",
+    "interrupt-controller": "boolean",
+}
+
+_STATUS_ENUM = "ok okay disabled reserved fail fail-sss".split()
+
+def _raw_default_property_for(name):
+    ret = {
+        'type': _DEFAULT_PROP_TYPES[name],
+        'required': False,
+    }
+    if name == 'status':
+        ret['enum'] = _STATUS_ENUM
+    return ret
+
+_DEFAULT_PROP_BINDING = Binding(
+    None, {},
+    raw={
+        'properties': {
+            name: _raw_default_property_for(name)
+            for name in _DEFAULT_PROP_TYPES
+        },
+    },
+    require_compatible=False, require_description=False,
+)
+
+_DEFAULT_PROP_SPECS = {
+    name: PropertySpec(name, _DEFAULT_PROP_BINDING)
+    for name in _DEFAULT_PROP_TYPES
+}
+
+# A set of vendor prefixes which are grandfathered in by Linux,
+# and therefore by us as well.
+_VENDOR_PREFIX_ALLOWED = set([
+    "at25", "bm", "devbus", "dmacap", "dsa",
+    "exynos", "fsia", "fsib", "gpio-fan", "gpio-key", "gpio", "gpmc",
+    "hdmi", "i2c-gpio", "keypad", "m25p", "max8952", "max8997",
+    "max8998", "mpmc", "pinctrl-single", "#pinctrl-single", "PowerPC",
+    "pl022", "pxa-mmc", "rcar_sound", "rotary-encoder", "s5m8767",
+    "sdhci", "simple-audio-card", "st-plgpio", "st-spics", "ts",
+])
diff --git a/tools/dts/python-devicetree/src/devicetree/grutils.py b/tools/dts/python-devicetree/src/devicetree/grutils.py
new file mode 100644
index 0000000000000000000000000000000000000000..c3ce825b2029fdca8c6e2e2bcc5b0f272f717c89
--- /dev/null
+++ b/tools/dts/python-devicetree/src/devicetree/grutils.py
@@ -0,0 +1,161 @@
+# Copyright 2009-2013, 2019 Peter A. Bigot
+#
+# SPDX-License-Identifier: Apache-2.0
+
+# This implementation is derived from the one in
+# [PyXB](https://github.com/pabigot/pyxb), stripped down and modified
+# specifically to manage edtlib Node instances.
+
+import collections
+
+class Graph:
+    """
+    Represent a directed graph with edtlib Node objects as nodes.
+
+    This is used to determine order dependencies among nodes in a
+    devicetree.  An edge from C{source} to C{target} indicates that
+    some aspect of C{source} requires that some aspect of C{target}
+    already be available.
+    """
+
+    def __init__(self, root=None):
+        self.__roots = None
+        if root is not None:
+            self.__roots = {root}
+        self.__edge_map = collections.defaultdict(set)
+        self.__reverse_map = collections.defaultdict(set)
+        self.__nodes = set()
+
+    def add_edge(self, source, target):
+        """
+        Add a directed edge from the C{source} to the C{target}.
+
+        The nodes are added to the graph if necessary.
+        """
+        self.__edge_map[source].add(target)
+        if source != target:
+            self.__reverse_map[target].add(source)
+        self.__nodes.add(source)
+        self.__nodes.add(target)
+
+    def roots(self):
+        """
+        Return the set of nodes calculated to be roots (i.e., those
+        that have no incoming edges).
+
+        This caches the roots calculated in a previous invocation.
+
+        @rtype: C{set}
+        """
+        if not self.__roots:
+            self.__roots = set()
+            for n in self.__nodes:
+                if n not in self.__reverse_map:
+                    self.__roots.add(n)
+        return self.__roots
+
+    def _tarjan(self):
+        # Execute Tarjan's algorithm on the graph.
+        #
+        # Tarjan's algorithm
+        # (http://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm)
+        # computes the strongly-connected components
+        # (http://en.wikipedia.org/wiki/Strongly_connected_component)
+        # of the graph: i.e., the sets of nodes that form a minimal
+        # closed set under edge transition.  In essence, the loops.
+        # We use this to detect groups of components that have a
+        # dependency cycle, and to impose a total order on components
+        # based on dependencies.
+
+        self.__stack = []
+        self.__scc_order = []
+        self.__index = 0
+        self.__tarjan_index = {}
+        self.__tarjan_low_link = {}
+        for v in self.__nodes:
+            self.__tarjan_index[v] = None
+        roots = sorted(self.roots(), key=node_key)
+        if self.__nodes and not roots:
+            raise Exception('TARJAN: No roots found in graph with {} nodes'.format(len(self.__nodes)))
+
+        for r in roots:
+            self._tarjan_root(r)
+
+        # Assign ordinals for edtlib
+        ordinal = 0
+        for scc in self.__scc_order:
+            # Zephyr customization: devicetree Node graphs should have
+            # no loops, so all SCCs should be singletons.  That may
+            # change in the future, but for now we only give an
+            # ordinal to singletons.
+            if len(scc) == 1:
+                scc[0].dep_ordinal = ordinal
+                ordinal += 1
+
+    def _tarjan_root(self, v):
+        # Do the work of Tarjan's algorithm for a given root node.
+
+        if self.__tarjan_index.get(v) is not None:
+            # "Root" was already reached.
+            return
+        self.__tarjan_index[v] = self.__tarjan_low_link[v] = self.__index
+        self.__index += 1
+        self.__stack.append(v)
+        source = v
+        for target in sorted(self.__edge_map[source], key=node_key):
+            if self.__tarjan_index[target] is None:
+                self._tarjan_root(target)
+                self.__tarjan_low_link[v] = min(self.__tarjan_low_link[v], self.__tarjan_low_link[target])
+            elif target in self.__stack:
+                self.__tarjan_low_link[v] = min(self.__tarjan_low_link[v], self.__tarjan_low_link[target])
+
+        if self.__tarjan_low_link[v] == self.__tarjan_index[v]:
+            scc = []
+            while True:
+                scc.append(self.__stack.pop())
+                if v == scc[-1]:
+                    break
+            self.__scc_order.append(scc)
+
+    def scc_order(self):
+        """Return the strongly-connected components in order.
+
+        The data structure is a list, in dependency order, of strongly
+        connected components (which can be single nodes).  Appearance
+        of a node in a set earlier in the list indicates that it has
+        no dependencies on any node that appears in a subsequent set.
+        This order is preferred over a depth-first-search order for
+        code generation, since it detects loops.
+        """
+        if not self.__scc_order:
+            self._tarjan()
+        return self.__scc_order
+    __scc_order = None
+
+    def depends_on(self, node):
+        """Get the nodes that 'node' directly depends on."""
+        return sorted(self.__edge_map[node], key=node_key)
+
+    def required_by(self, node):
+        """Get the nodes that directly depend on 'node'."""
+        return sorted(self.__reverse_map[node], key=node_key)
+
+def node_key(node):
+    # This sort key ensures that sibling nodes with the same name will
+    # use unit addresses as tiebreakers. That in turn ensures ordinals
+    # for otherwise indistinguishable siblings are in increasing order
+    # by unit address, which is convenient for displaying output.
+
+    if node.parent:
+        parent_path = node.parent.path
+    else:
+        parent_path = '/'
+
+    if node.unit_addr is not None:
+        name = node.name.rsplit('@', 1)[0]
+        unit_addr = node.unit_addr
+    else:
+        name = node.name
+        unit_addr = -1
+
+    return (parent_path, name, unit_addr)
diff --git a/tools/dts/python-devicetree/tests/test-bindings-2/multidir.yaml b/tools/dts/python-devicetree/tests/test-bindings-2/multidir.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..19721b2ae21e1b7667325ac9b56ba1760108cca2
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-2/multidir.yaml
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Binding in test-bindings-2/
+
+compatible: "in-dir-2"
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/README.rst b/tools/dts/python-devicetree/tests/test-bindings-include/README.rst
new file mode 100644
index 0000000000000000000000000000000000000000..c8ab889bcbb5f985e27176006bfcd0f08ebe801e
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/README.rst
@@ -0,0 +1 @@
+This directory contains bindings used to test the 'include:' feature.
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/allow-and-blocklist-child.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/allow-and-blocklist-child.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..17711202b427006ea160580c880f7161bf97c592
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/allow-and-blocklist-child.yaml
@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: |
+  An include must not give both an allowlist and a blocklist in a
+  child binding. This binding should cause an error.
+compatible: allow-and-blocklist-child
+include:
+  - name: include.yaml
+    child-binding:
+      property-blocklist: [x]
+      property-allowlist: [y]
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/allow-and-blocklist.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/allow-and-blocklist.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..80af46561f99ab38d64fd45203ac4deb55522284
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/allow-and-blocklist.yaml
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: |
+  An include must not give both an allowlist and a blocklist.
+  This binding should cause an error.
+compatible: allow-and-blocklist
+include:
+  - name: include.yaml
+    property-blocklist: [x]
+    property-allowlist: [y]
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/allow-not-list.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/allow-not-list.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..4ec3d87fb559ea5d026fdaa5b07849fd64178fc5
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/allow-not-list.yaml
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: |
+  A property-allowlist, if given, must be a list. This binding should
+  cause an error.
+compatible: allow-not-list
+include:
+  - name: include.yaml
+    property-allowlist:
+      foo:
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/allowlist.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/allowlist.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..4cd2c52494fc746d802c2cadf8f0930ee3174fd3
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/allowlist.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Valid property-allowlist.
+compatible: allowlist
+include:
+  - name: include.yaml
+    property-allowlist: [x]
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/block-not-list.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/block-not-list.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..bf58da5a7799e57ae0b761bde2ce69e7b46863b8
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/block-not-list.yaml
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: |
+  A property-blocklist, if given, must be a list. This binding should
+  cause an error.
+compatible: block-not-list
+include:
+  - name: include.yaml
+    property-blocklist:
+      foo:
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/blocklist.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/blocklist.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a56db024bde8fde163d96275f4c898f433e023f1
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/blocklist.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Valid property-blocklist.
+compatible: blocklist
+include:
+  - name: include.yaml
+    property-blocklist: [x]
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/empty-allowlist.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/empty-allowlist.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c217d068bb1dd91f5853b1ad316fa6f596e9307e
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/empty-allowlist.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: An empty property-allowlist is valid.
+compatible: empty-allowlist
+include:
+  - name: include.yaml
+    property-allowlist: []
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/empty-blocklist.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/empty-blocklist.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..76bed12f5034094a7bb3c168d0548b7edf1d2839
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/empty-blocklist.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: An empty property-blocklist is valid.
+compatible: empty-blocklist
+include:
+  - name: include.yaml
+    property-blocklist: []
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/filter-child-bindings.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/filter-child-bindings.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..1547e3687e3db74b891b2097009b5697615d96a0
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/filter-child-bindings.yaml
@@ -0,0 +1,11 @@
+description: Test binding for filtering 'child-binding' properties
+
+include:
+  - name: include.yaml
+    property-allowlist: [x]
+    child-binding:
+      property-blocklist: [child-prop-1]
+      child-binding:
+        property-allowlist: [grandchild-prop-1]
+
+compatible: filter-child-bindings
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/include-2.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/include-2.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..6fe58224674e48df80a124cdbd6c7faf5bedb0c3
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/include-2.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Second file for testing "intermixed" includes.
+compatible: include-2
+properties:
+  a:
+    type: int
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/include-invalid-keys.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/include-invalid-keys.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..1b75430360ee6c139fcd50ec72939c817455051e
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/include-invalid-keys.yaml
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: |
+  Invalid include element: invalid keys are present.
+compatible: include-invalid-keys
+include:
+  - name: include.yaml
+    property-allowlist: [x]
+    bad-key-1: 3
+    bad-key-2: 3
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/include-invalid-type.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/include-invalid-type.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a11085dc244c2d221622da81e8cf677f586f25eb
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/include-invalid-type.yaml
@@ -0,0 +1,5 @@
+description: |
+  Invalid include: wrong top level type.
+compatible: include-invalid-type
+include:
+  a-map-is-not-allowed-here: 3
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/include-no-list.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/include-no-list.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..940e824985dcbfc41dfdb4fa1ffb346e1e0798c4
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/include-no-list.yaml
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: A map element with just a name is valid, and has no filters.
+compatible: include-no-list
+include:
+  - name: include.yaml
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/include-no-name.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/include-no-name.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3202879aa49c38c7a052daad92a5ab68bfde09c3
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/include-no-name.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: |
+  Invalid include element: no name key is present.
+compatible: include-no-name
+include:
+  - property-allowlist: [x]
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/include.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/include.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..455992009ea37f4c59368054ea5681689202e00e
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/include.yaml
@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Test file for including other bindings
+compatible: include
+properties:
+  x:
+    type: int
+  y:
+    type: int
+  z:
+    type: int
+child-binding:
+  properties:
+    child-prop-1:
+      type: int
+    child-prop-2:
+      type: int
+
+  child-binding:
+    properties:
+      grandchild-prop-1:
+        type: int
+      grandchild-prop-2:
+        type: int
diff --git a/tools/dts/python-devicetree/tests/test-bindings-include/intermixed.yaml b/tools/dts/python-devicetree/tests/test-bindings-include/intermixed.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2837a3ec893a528821792a855d92147c0d3857c6
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings-include/intermixed.yaml
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Including intermixed file names and maps is valid.
+compatible: intermixed
+include:
+  - name: include.yaml
+    property-allowlist: [x]
+  - include-2.yaml
diff --git a/tools/dts/python-devicetree/tests/test-bindings/bar-bus.yaml b/tools/dts/python-devicetree/tests/test-bindings/bar-bus.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e429e3010dec892c49ddc1f98e30938b31cdcde6
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/bar-bus.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Bar bus controller
+
+compatible: "bar-bus"
+
+bus: "bar"
diff --git a/tools/dts/python-devicetree/tests/test-bindings/child-binding-with-compat.yaml b/tools/dts/python-devicetree/tests/test-bindings/child-binding-with-compat.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..1744ad2fe763db932c495576a3fc69b20090f90b
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/child-binding-with-compat.yaml
@@ -0,0 +1,20 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: child-binding with separate compatible than the parent
+
+compatible: "top-binding-with-compat"
+
+child-binding:
+    compatible: child-compat
+    description: child node
+    properties:
+        child-prop:
+            type: int
+            required: true
+
+    child-binding:
+        description: grandchild node
+        properties:
+            grandchild-prop:
+                type: int
+                required: true
diff --git a/tools/dts/python-devicetree/tests/test-bindings/child-binding.yaml b/tools/dts/python-devicetree/tests/test-bindings/child-binding.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..5319dea8ac47fdd78ac5393c8d9962503657d90c
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/child-binding.yaml
@@ -0,0 +1,19 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: child-binding test
+
+compatible: "top-binding"
+
+child-binding:
+    description: child node
+    properties:
+        child-prop:
+            type: int
+            required: true
+
+    child-binding:
+        description: grandchild node
+        properties:
+            grandchild-prop:
+                type: int
+                required: true
diff --git a/tools/dts/python-devicetree/tests/test-bindings/child.yaml b/tools/dts/python-devicetree/tests/test-bindings/child.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..091c6594337bfe372f415bf4e66094fea8673386
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/child.yaml
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+include: [grandchild-1.yaml, grandchild-2.yaml, grandchild-3.yaml]
+
+properties:
+    bar:
+        required: true
+        type: int
diff --git a/tools/dts/python-devicetree/tests/test-bindings/defaults.yaml b/tools/dts/python-devicetree/tests/test-bindings/defaults.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..706067c59de264f6ebf9af7707588672fa6b4ac2
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/defaults.yaml
@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Property default value test
+
+compatible: "defaults"
+
+properties:
+    int:
+        type: int
+        required: false
+        default: 123
+
+    array:
+        type: array
+        required: false
+        default: [1, 2, 3]
+
+    uint8-array:
+        type: uint8-array
+        required: false
+        default: [0x89, 0xAB, 0xCD]
+
+    string:
+        type: string
+        required: false
+        default: "hello"
+
+    string-array:
+        type: string-array
+        required: false
+        default: ["hello", "there"]
+
+    default-not-used:
+        type: int
+        required: false
+        default: 123
diff --git a/tools/dts/python-devicetree/tests/test-bindings/deprecated.yaml b/tools/dts/python-devicetree/tests/test-bindings/deprecated.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d8c72e5c053bf039644d63abbcb2342b1c12bddb
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/deprecated.yaml
@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Property deprecated value test
+
+compatible: "test-deprecated"
+
+properties:
+    oldprop:
+        type: int
+        deprecated: true
+        required: false
+
+    curprop:
+        type: int
+        required: false
diff --git a/tools/dts/python-devicetree/tests/test-bindings/device-on-any-bus.yaml b/tools/dts/python-devicetree/tests/test-bindings/device-on-any-bus.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..06c29e4ae0e347b23d9cfe24c4c734cdaa99c66f
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/device-on-any-bus.yaml
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Device on any bus
+
+compatible: "on-any-bus"
diff --git a/tools/dts/python-devicetree/tests/test-bindings/device-on-bar-bus.yaml b/tools/dts/python-devicetree/tests/test-bindings/device-on-bar-bus.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d2c72bb5a9385ba220a0c34348c0b70f3a37777c
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/device-on-bar-bus.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Device on bar bus
+
+compatible: "on-bus"
+
+on-bus: "bar"
diff --git a/tools/dts/python-devicetree/tests/test-bindings/device-on-foo-bus.yaml b/tools/dts/python-devicetree/tests/test-bindings/device-on-foo-bus.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3ed4a75255b196418342858804c4939fa5f1d285
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/device-on-foo-bus.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Device on foo bus
+
+compatible: "on-bus"
+
+on-bus: "foo"
diff --git a/tools/dts/python-devicetree/tests/test-bindings/enums.yaml b/tools/dts/python-devicetree/tests/test-bindings/enums.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..f36b89b26eb2ed0681c6fa9268007e76cef09196
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/enums.yaml
@@ -0,0 +1,36 @@
+# Copyright (c) 2020 Nordic Semiconductor ASA
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Property enum test
+
+compatible: "enums"
+
+properties:
+  int-enum:
+    type: int
+    enum:
+      - 1
+      - 2
+      - 3
+
+  string-enum:                  # not tokenizable
+    type: string
+    enum:
+      - foo bar
+      - foo_bar
+
+  tokenizable-lower-enum:       # tokenizable in lowercase only
+    type: string
+    enum:
+      - bar
+      - BAR
+
+  tokenizable-enum:             # tokenizable in lower and uppercase
+    type: string
+    enum:
+      - bar
+      - whitespace is ok
+      - 123 is ok
+
+  no-enum:
+    type: string
diff --git a/tools/dts/python-devicetree/tests/test-bindings/false-positive.yaml b/tools/dts/python-devicetree/tests/test-bindings/false-positive.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..30de8fbb163e2f22ee9acaf70c55b736f0d6ca67
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/false-positive.yaml
@@ -0,0 +1,4 @@
+# A file that mentions a 'compatible' string without actually implementing it.
+# Used to check for issues with how we optimize binding loading.
+
+# props
diff --git a/tools/dts/python-devicetree/tests/test-bindings/foo-bus.yaml b/tools/dts/python-devicetree/tests/test-bindings/foo-bus.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a3a98d330bd1d9c2e6a1475fd1e21f9872a2ab64
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/foo-bus.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Foo bus controller
+
+compatible: "foo-bus"
+
+bus: "foo"
diff --git a/tools/dts/python-devicetree/tests/test-bindings/foo-optional.yaml b/tools/dts/python-devicetree/tests/test-bindings/foo-optional.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..5383ade22ed60288374c0873c472a9590be9eb07
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/foo-optional.yaml
@@ -0,0 +1,4 @@
+properties:
+    foo:
+        type: int
+        required: false
diff --git a/tools/dts/python-devicetree/tests/test-bindings/foo-required.yaml b/tools/dts/python-devicetree/tests/test-bindings/foo-required.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..1544e1cd40bb192476bb4d45d21e84f98c8991f3
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/foo-required.yaml
@@ -0,0 +1,4 @@
+properties:
+    foo:
+        type: int
+        required: true
diff --git a/tools/dts/python-devicetree/tests/test-bindings/gpio-dst.yaml b/tools/dts/python-devicetree/tests/test-bindings/gpio-dst.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..19db3161440aea1190c142bfca987e6b6e8ea31c
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/gpio-dst.yaml
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: GPIO destination for mapping test
+
+compatible: "gpio-dst"
+
+gpio-cells:
+    - val
diff --git a/tools/dts/python-devicetree/tests/test-bindings/gpio-src.yaml b/tools/dts/python-devicetree/tests/test-bindings/gpio-src.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..b7e5c33571a2b2a52af5ee2189fe78c33cc19b32
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/gpio-src.yaml
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: GPIO source for mapping test
+
+compatible: "gpio-src"
+
+properties:
+    foo-gpios:
+        type: phandle-array
diff --git a/tools/dts/python-devicetree/tests/test-bindings/grandchild-1.yaml b/tools/dts/python-devicetree/tests/test-bindings/grandchild-1.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..249158f52397996f00e885cb84631ece0763472f
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/grandchild-1.yaml
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+properties:
+    foo:
+        required: false
+        type: int
+
+    baz:
+        required: true
+        type: int
diff --git a/tools/dts/python-devicetree/tests/test-bindings/grandchild-2.yaml b/tools/dts/python-devicetree/tests/test-bindings/grandchild-2.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..d7d0b5c3731f1c7e3dceeff7151626ddcc910ceb
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/grandchild-2.yaml
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+properties:
+    baz:
+        required: true
+        type: int
diff --git a/tools/dts/python-devicetree/tests/test-bindings/grandchild-3.yaml b/tools/dts/python-devicetree/tests/test-bindings/grandchild-3.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c1ba6b8e807a974f72d498ccfdc83332d2a94f8f
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/grandchild-3.yaml
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+properties:
+    qaz:
+        required: true
+        type: int
diff --git a/tools/dts/python-devicetree/tests/test-bindings/interrupt-1-cell.yaml b/tools/dts/python-devicetree/tests/test-bindings/interrupt-1-cell.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..ab2db66790f276b69209e20c903ddd44b0ef9f8e
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/interrupt-1-cell.yaml
@@ -0,0 +1,8 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Interrupt controller with one cell
+
+compatible: "interrupt-one-cell"
+
+interrupt-cells:
+    - one
diff --git a/tools/dts/python-devicetree/tests/test-bindings/interrupt-2-cell.yaml b/tools/dts/python-devicetree/tests/test-bindings/interrupt-2-cell.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..2c3144d68f4a3a1047416727695456e8b93d10c5
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/interrupt-2-cell.yaml
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Interrupt controller with two cells
+
+compatible: "interrupt-two-cell"
+
+interrupt-cells:
+    - one
+    - two
diff --git a/tools/dts/python-devicetree/tests/test-bindings/interrupt-3-cell.yaml b/tools/dts/python-devicetree/tests/test-bindings/interrupt-3-cell.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..846dee07a60fcab9a6dc2b297848817566d50859
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/interrupt-3-cell.yaml
@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Interrupt controller with three cells
+
+compatible: "interrupt-three-cell"
+
+interrupt-cells:
+    - one
+    - two
+    - three
diff --git a/tools/dts/python-devicetree/tests/test-bindings/multidir.yaml b/tools/dts/python-devicetree/tests/test-bindings/multidir.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..8504475397f2a8aa5673c87b4d0c38bf654df77a
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/multidir.yaml
@@ -0,0 +1,5 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Binding in test-bindings/
+
+compatible: "in-dir-1"
diff --git a/tools/dts/python-devicetree/tests/test-bindings/order-1.yaml b/tools/dts/python-devicetree/tests/test-bindings/order-1.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e6024a8bdb34a87fb36fb874c005c3be4055a285
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/order-1.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Include ordering test
+
+compatible: "order-1"
+
+include: ["foo-required.yaml", "foo-optional.yaml"]
diff --git a/tools/dts/python-devicetree/tests/test-bindings/order-2.yaml b/tools/dts/python-devicetree/tests/test-bindings/order-2.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..cad1f9b4400607780093cca0092bc6d9b8c6c68b
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/order-2.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Include ordering test
+
+compatible: "order-2"
+
+include: ["foo-optional.yaml", "foo-required.yaml"]
diff --git a/tools/dts/python-devicetree/tests/test-bindings/parent.yaml b/tools/dts/python-devicetree/tests/test-bindings/parent.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..8a0e0f45934886af029b53392fc120b5d99f605d
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/parent.yaml
@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Parent binding
+
+compatible: "binding-include-test"
+
+include: child.yaml
+
+properties:
+    foo:
+        # Changed from not being required in grandchild-1.yaml
+        required: true
+        # Type set in grandchild
diff --git a/tools/dts/python-devicetree/tests/test-bindings/phandle-array-controller-0.yaml b/tools/dts/python-devicetree/tests/test-bindings/phandle-array-controller-0.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3b2430c41913354dff6fa02d8156be880d46abae
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/phandle-array-controller-0.yaml
@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Controller with zero data values
+
+compatible: "phandle-array-controller-0"
+
+phandle-array-foo-cells: []
diff --git a/tools/dts/python-devicetree/tests/test-bindings/phandle-array-controller-1.yaml b/tools/dts/python-devicetree/tests/test-bindings/phandle-array-controller-1.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..9d5c6c5cd609da701f319bbcfdfde739b2437ab0
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/phandle-array-controller-1.yaml
@@ -0,0 +1,11 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Controller with one data value
+
+compatible: "phandle-array-controller-1"
+
+phandle-array-foo-cells:
+    - one
+
+gpio-cells:
+    - gpio-one
diff --git a/tools/dts/python-devicetree/tests/test-bindings/phandle-array-controller-2.yaml b/tools/dts/python-devicetree/tests/test-bindings/phandle-array-controller-2.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..e7a3cab664f8c64213045533e003824e0f9e8512
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/phandle-array-controller-2.yaml
@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Controller with two data values
+
+compatible: "phandle-array-controller-2"
+
+phandle-array-foo-cells:
+    - one
+    - two
diff --git a/tools/dts/python-devicetree/tests/test-bindings/props.yaml b/tools/dts/python-devicetree/tests/test-bindings/props.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..40b4cb9bd0e61059863e81da122ed7742c0a7c8d
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-bindings/props.yaml
@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: BSD-3-Clause
+
+description: Device.props test
+
+compatible: "props"
+
+properties:
+    nonexistent-boolean:
+        type: boolean
+
+    existent-boolean:
+        type: boolean
+
+    int:
+        type: int
+        const: 1
+
+    array:
+        type: array
+
+    uint8-array:
+        type: uint8-array
+
+    string:
+        type: string
+        const: "foo"
+
+    string-array:
+        type: string-array
+
+    phandle-ref:
+        type: phandle
+
+    phandle-refs:
+        type: phandles
+
+    phandle-array-foos:
+        type: phandle-array
+
+    phandle-array-foo-names:
+        type: string-array
+
+    # There's some slight special-casing for GPIOs in that 'foo-gpios = ...'
+    # gets resolved to #gpio-cells rather than #foo-gpio-cells, so test that
+    # too
+    foo-gpios:
+        type: phandle-array
+
+    path:
+        type: path
diff --git a/tools/dts/python-devicetree/tests/test-multidir.dts b/tools/dts/python-devicetree/tests/test-multidir.dts
new file mode 100644
index 0000000000000000000000000000000000000000..4bd046317d2dd1afdecce4d6033b6e3810be74de
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test-multidir.dts
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2019, Nordic Semiconductor
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+// Used by testedtlib.py. Dedicated file for testing having multiple binding
+// directories.
+
+/dts-v1/;
+
+/ {
+	in-dir-1 {
+		compatible = "in-dir-1";
+	};
+	in-dir-2 {
+		compatible = "in-dir-2";
+	};
+};
diff --git a/tools/dts/python-devicetree/tests/test.dts b/tools/dts/python-devicetree/tests/test.dts
new file mode 100644
index 0000000000000000000000000000000000000000..0e077fdf6279915999c3999d7bd27d751c091702
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test.dts
@@ -0,0 +1,430 @@
+/*
+ * Copyright (c) 2019, Nordic Semiconductor
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+// Used by testedtlib.py
+
+/dts-v1/;
+
+/ {
+	//
+	// Interrupts
+	//
+
+	interrupt-parent-test {
+		controller {
+			compatible = "interrupt-three-cell";
+			#interrupt-cells = <3>;
+			interrupt-controller;
+		};
+		node {
+			interrupts = <1 2 3 4 5 6>;
+			interrupt-names = "foo", "bar";
+			interrupt-parent = <&{/interrupt-parent-test/controller}>;
+		};
+	};
+	interrupts-extended-test {
+		controller-0 {
+			compatible = "interrupt-one-cell";
+			#interrupt-cells = <1>;
+			interrupt-controller;
+		};
+		controller-1 {
+			compatible = "interrupt-two-cell";
+			#interrupt-cells = <2>;
+			interrupt-controller;
+		};
+		controller-2 {
+			compatible = "interrupt-three-cell";
+			#interrupt-cells = <3>;
+			interrupt-controller;
+		};
+		node {
+			interrupts-extended = <
+				&{/interrupts-extended-test/controller-0} 1
+				&{/interrupts-extended-test/controller-1} 2 3
+				&{/interrupts-extended-test/controller-2} 4 5 6>;
+		};
+	};
+	interrupt-map-test {
+		#address-cells = <2>;
+		#size-cells = <0>;
+
+		controller-0 {
+			compatible = "interrupt-one-cell";
+			#address-cells = <1>;
+			#interrupt-cells = <1>;
+			interrupt-controller;
+		};
+		controller-1 {
+			compatible = "interrupt-two-cell";
+			#address-cells = <2>;
+			#interrupt-cells = <2>;
+			interrupt-controller;
+		};
+		controller-2 {
+			compatible = "interrupt-three-cell";
+			#address-cells = <3>;
+			#interrupt-cells = <3>;
+			interrupt-controller;
+		};
+		nexus {
+			#interrupt-cells = <2>;
+			interrupt-map = <
+				0 0  0 0  &{/interrupt-map-test/controller-0}  0      0
+				0 0  0 1  &{/interrupt-map-test/controller-1}  0 0    0 1
+				0 0  0 2  &{/interrupt-map-test/controller-2}  0 0 0  0 0 2
+				0 1  0 0  &{/interrupt-map-test/controller-0}  0      3
+				0 1  0 1  &{/interrupt-map-test/controller-1}  0 0    0 4
+				0 1  0 2  &{/interrupt-map-test/controller-2}  0 0 0  0 0 5>;
+		};
+		node@0 {
+			reg = <0 0>;
+			interrupts = <0 0 0 1 0 2>;
+			interrupt-parent = <&{/interrupt-map-test/nexus}>;
+		};
+		node@1 {
+			reg = <0 1>;
+			interrupts-extended = <
+			    &{/interrupt-map-test/nexus} 0 0
+			    &{/interrupt-map-test/nexus} 0 1
+			    &{/interrupt-map-test/nexus} 0 2>;
+		};
+	};
+	interrupt-map-bitops-test {
+		#address-cells = <2>;
+		#size-cells = <0>;
+
+		controller {
+			compatible = "interrupt-two-cell";
+			#address-cells = <0>;
+			#interrupt-cells = <2>;
+			interrupt-controller;
+		};
+		nexus {
+			#interrupt-cells = <2>;
+			interrupt-map = <
+			    6 6  6 6  &{/interrupt-map-bitops-test/controller}  2 1
+			>;
+			interrupt-map-mask = <0xE 0x7 0xE 0x7>;
+			// Not specified in the DT spec., but shows up due to
+			// common code with GPIO. Might as well test it here.
+			interrupt-map-pass-thru = <1 2 3 3>;
+		};
+		// Child unit specifier: 00000007 0000000E 00000007 0000000E
+		// Mask:                 0000000E 00000007 0000000E 00000007
+		// Pass-thru:            00000001 00000002 00000003 00000003
+		node@70000000E {
+			reg = <0x7 0xE>;
+			interrupt-parent = <&{/interrupt-map-bitops-test/nexus}>;
+			interrupts = <0x7 0xE>;
+		};
+	};
+
+	//
+	// 'reg'
+	//
+
+	reg-zero-address-cells {
+		#address-cells = <0>;
+		#size-cells = <1>;
+
+		node {
+			reg = <1 2>;
+		};
+	};
+	reg-zero-size-cells {
+		#address-cells = <1>;
+		#size-cells = <0>;
+
+		node {
+			reg = <1 2>;
+		};
+	};
+	// Use implied #size-cells = <1>
+	reg-ranges {
+		#address-cells = <2>;
+
+		parent {
+			#address-cells = <1>;
+			ranges = <1  0xA 0xB  1 /* 1    -> 0xA 0xB */
+				  2  0xC 0xD  2 /* 2..3 -> 0xC 0xD */
+				  4  0xE 0xF  1 /* 4    -> 0xE 0xF */
+				 >;
+
+			node {
+				reg = <5 1 /* Matches no range */
+				       4 1 /* Matches third range */
+				       3 1 /* Matches second range */
+				       2 1 /* Matches second range */
+				       1 1 /* Matches first range */
+				       0 1 /* Matches no range */
+				       >;
+			};
+		};
+	};
+	// Build up <3 2 1> address with nested 'ranges'
+	reg-nested-ranges {
+		#address-cells = <3>;
+
+		grandparent {
+			#address-cells = <2>;
+			#size-cells = <2>;
+			ranges = <0 0  3 0 0  2 2>;
+
+			parent {
+				#address-cells = <1>;
+				ranges = <0  2 0  2>;
+
+				node {
+					reg = <1 1>;
+				};
+			};
+		};
+	};
+
+	//
+	// 'pinctrl-<index>'
+	//
+
+	pinctrl {
+		dev {
+			pinctrl-0 = <>;
+			pinctrl-1 = <&{/pinctrl/pincontroller/state-1}>;
+			pinctrl-2 = <&{/pinctrl/pincontroller/state-1}
+				     &{/pinctrl/pincontroller/state-2}>;
+			pinctrl-names = "zero", "one", "two";
+		};
+		pincontroller {
+			state-1 {
+			};
+			state-2 {
+			};
+		};
+	};
+
+	//
+	// For testing Node.parent and Node.children
+	//
+
+	parent {
+		child-1 {
+		};
+		child-2 {
+			grandchild {
+			};
+		};
+	};
+
+	//
+	// For testing 'include:'
+	//
+
+	binding-include {
+		compatible = "binding-include-test";
+		foo = <0>;
+		bar = <1>;
+		baz = <2>;
+		qaz = <3>;
+	};
+
+	//
+	// For testing Node.props (derived from 'properties:' in the binding)
+	//
+
+	props {
+		compatible = "props";
+		existent-boolean;
+		int = <1>;
+		array = <1 2 3>;
+		uint8-array = [ 12 34 ];
+		string = "foo";
+		string-array = "foo", "bar", "baz";
+		phandle-ref = < &{/ctrl-1} >;
+		phandle-refs = < &{/ctrl-1} &{/ctrl-2} >;
+		phandle-array-foos = < &{/ctrl-1} 1 &{/ctrl-2} 2 3 >;
+		foo-gpios = < &{/ctrl-1} 1 >;
+		path = &{/ctrl-1};
+	};
+
+	ctrl-1 {
+		compatible = "phandle-array-controller-1";
+		#phandle-array-foo-cells = <1>;
+		#gpio-cells = <1>;
+	};
+
+	ctrl-2 {
+		compatible = "phandle-array-controller-2";
+		#phandle-array-foo-cells = <2>;
+	};
+
+	props-2 {
+		compatible = "props";
+		phandle-array-foos = < &{/ctrl-0-1} 0 &{/ctrl-0-2} >;
+		phandle-array-foo-names = "a", "missing", "b";
+	};
+
+	ctrl-0-1 {
+		compatible = "phandle-array-controller-0";
+		#phandle-array-foo-cells = <0>;
+	};
+
+	ctrl-0-2 {
+		compatible = "phandle-array-controller-0";
+		#phandle-array-foo-cells = <0>;
+	};
+
+	//
+	// Test <prefix>-map, via gpio-map
+	//
+
+	gpio-map {
+		source {
+			compatible = "gpio-src";
+			foo-gpios = <&{/gpio-map/connector} 3 4
+				     &{/gpio-map/connector} 1 2>;
+		};
+		connector {
+			#gpio-cells = <2>;
+			// Use different data lengths for source and
+			// destination to make it a bit trickier
+			gpio-map = <1 2 &{/gpio-map/destination} 5
+				    3 4 &{/gpio-map/destination} 6>;
+		};
+		destination {
+			compatible = "gpio-dst";
+			gpio-controller;
+			#gpio-cells = <1>;
+		};
+	};
+
+	//
+	// For testing Node.props with 'default:' values in binding
+	//
+
+	defaults {
+		compatible = "defaults";
+		// Should override the 'default:' in the binding
+		default-not-used = <234>;
+	};
+
+	//
+	// For testing 'enum:'
+	//
+
+	enums {
+		compatible = "enums";
+		int-enum = <1>;
+		string-enum = "foo_bar";
+		tokenizable-enum = "123 is ok";
+		tokenizable-lower-enum = "bar";
+		no-enum = "baz";
+	};
+
+	//
+	// For testing 'bus:' and 'on-bus:'
+	//
+
+	buses {
+		// The 'node' nodes below will map to different bindings since
+		// they appear on different buses
+		foo-bus {
+			compatible = "foo-bus";
+			node1 {
+				compatible = "on-bus", "on-any-bus";
+				nested {
+					compatible = "on-bus";
+				};
+			};
+			node2 {
+				compatible = "on-any-bus", "on-bus";
+			};
+		};
+		bar-bus {
+			compatible = "bar-bus";
+			node {
+				compatible = "on-bus";
+			};
+		};
+		no-bus-node {
+			compatible = "on-any-bus";
+		};
+	};
+
+	//
+	// Node with 'child-binding:' in binding (along with a recursive
+	// 'child-binding:')
+	//
+
+	child-binding {
+		compatible = "top-binding";
+		child-1 {
+			child-prop = <1>;
+			grandchild {
+				grandchild-prop = <2>;
+			};
+		};
+		child-2 {
+			child-prop = <3>;
+		};
+	};
+
+	//
+	// zephyr,user binding inference
+	//
+
+	zephyr,user {
+		boolean;
+		bytes = [81 82 83];
+		number = <23>;
+		numbers = <1>, <2>, <3>;
+		string = "text";
+		strings = "a", "b", "c";
+		handle = <&{/ctrl-1}>;
+		phandles = <&{/ctrl-1}>, <&{/ctrl-2}>;
+		phandle-array-foos = <&{/ctrl-2} 1 2>;
+	};
+
+	//
+	// For testing that neither 'include: [foo.yaml, bar.yaml]' nor
+	// 'include: [bar.yaml, foo.yaml]' causes errors when one of the files
+	// has 'required: true' and the other 'required: false'
+	//
+
+	include-order {
+		node-1 {
+			compatible = "order-1";
+			foo = <1>;
+		};
+		node-2 {
+			compatible = "order-2";
+			foo = <2>;
+		};
+	};
+
+	//
+	// For testing deprecated property
+	//
+	test-deprecated {
+		compatible = "test-deprecated";
+		oldprop = <4>;	/* deprecated property */
+		curprop = <5>;
+	};
+
+
+	//
+	// For testing deprecated features
+	//
+
+	deprecated {
+		compatible = "deprecated";
+		required = <1>;
+		required-2 = <2>;
+		#foo-cells = <2>;
+		sub-node {
+			foos = <&{/deprecated} 1 2>;
+		};
+	};
+};
diff --git a/tools/dts/python-devicetree/tests/test_dtlib.py b/tools/dts/python-devicetree/tests/test_dtlib.py
new file mode 100644
index 0000000000000000000000000000000000000000..13e5544da6a1bf8a622766de9f1e7e6da748ca18
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test_dtlib.py
@@ -0,0 +1,2264 @@
+# Copyright (c) 2019, Nordic Semiconductor
+# SPDX-License-Identifier: BSD-3-Clause
+
+import contextlib
+import os
+import re
+import tempfile
+
+import pytest
+
+from devicetree import dtlib
+
+# Test suite for dtlib.py.
+#
+# Run it using pytest (https://docs.pytest.org/en/stable/usage.html):
+#
+#   $ pytest tests/test_dtlib.py
+#
+# Extra options you can pass to pytest for debugging:
+#
+#   - to stop on the first failure with shorter traceback output,
+#     use '-x --tb=native'
+#   - to drop into a debugger on failure, use '--pdb'
+#   - to run a particular test function or functions, use
+#     '-k test_function_pattern_goes_here'
+
+def parse(dts, include_path=(), **kwargs):
+    '''Parse a DTS string 'dts', using the given include path.
+
+    Any kwargs are passed on to DT().'''
+
+    fd, path = tempfile.mkstemp(prefix='pytest-', suffix='.dts')
+    try:
+        os.write(fd, dts.encode('utf-8'))
+        return dtlib.DT(path, include_path, **kwargs)
+    finally:
+        os.close(fd)
+        os.unlink(path)
+
+def verify_parse(dts, expected, include_path=()):
+    '''Like parse(), but also verifies that the parsed DT object's string
+    representation is expected[1:-1].
+
+    The [1:] is so that the first line can be put on a separate line
+    after triple quotes, as is done below.'''
+
+    dt = parse(dts[1:], include_path)
+
+    actual = str(dt)
+    expected = expected[1:-1]
+    assert actual == expected, f'unexpected round-trip on {dts}'
+
+    return dt
+
+def verify_error(dts, expected_msg):
+    '''Verify that parsing 'dts' results in a DTError with the
+    given error message 'msg'. The message must match exactly.'''
+
+    with pytest.raises(dtlib.DTError) as e:
+        parse(dts[1:])
+    actual_msg = str(e.value)
+    assert actual_msg == expected_msg, f'wrong error from {dts}'
+
+def verify_error_endswith(dts, expected_msg):
+    '''
+    Like verify_error(), but checks the message ends with
+    'expected_msg' instead of checking for strict equality.
+    '''
+
+    with pytest.raises(dtlib.DTError) as e:
+        parse(dts[1:])
+    actual_msg = str(e.value)
+    assert actual_msg.endswith(expected_msg), f'wrong error from {dts}'
+
+def verify_error_matches(dts, expected_re):
+    '''
+    Like verify_error(), but checks the message fully matches regular
+    expression 'expected_re' instead of checking for strict equality.
+    '''
+
+    with pytest.raises(dtlib.DTError) as e:
+        parse(dts[1:])
+    actual_msg = str(e.value)
+    assert re.fullmatch(expected_re, actual_msg), \
+        f'wrong error from {dts}' \
+        f'actual message:\n{actual_msg!r}\n' \
+        f'does not match:\n{expected_re!r}'
+
+@contextlib.contextmanager
+def temporary_chdir(dirname):
+    '''A context manager that changes directory to 'dirname'.
+
+    The current working directory is unconditionally returned to its
+    present location after the context manager exits.
+    '''
+    here = os.getcwd()
+    try:
+        os.chdir(dirname)
+        yield
+    finally:
+        os.chdir(here)
+
+def test_cell_parsing():
+    '''Miscellaneous properties containing zero or more cells'''
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	a;
+	b = < >;
+	c = [ ];
+	d = < 10 20 >;
+	e = < 0U 1L 2UL 3LL 4ULL >;
+	f = < 0x10 0x20 >;
+	g = < 010 020 >;
+	h = /bits/ 8 < 0x10 0x20 (-1) >;
+	i = /bits/ 16 < 0x10 0x20 (-1) >;
+	j = /bits/ 32 < 0x10 0x20 (-1) >;
+	k = /bits/ 64 < 0x10 0x20 (-1) >;
+	l = < 'a' 'b' 'c' >;
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a;
+	b;
+	c;
+	d = < 0xa 0x14 >;
+	e = < 0x0 0x1 0x2 0x3 0x4 >;
+	f = < 0x10 0x20 >;
+	g = < 0x8 0x10 >;
+	h = [ 10 20 FF ];
+	i = /bits/ 16 < 0x10 0x20 0xffff >;
+	j = < 0x10 0x20 0xffffffff >;
+	k = /bits/ 64 < 0x10 0x20 0xffffffffffffffff >;
+	l = < 0x61 0x62 0x63 >;
+};
+""")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	a = /bits/ 16 < 0x10000 >;
+};
+""",
+":4 (column 18): parse error: 65536 does not fit in 16 bits")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	a = < 0x100000000 >;
+};
+""",
+":4 (column 8): parse error: 4294967296 does not fit in 32 bits")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	a = /bits/ 128 < 0 >;
+};
+""",
+":4 (column 13): parse error: expected 8, 16, 32, or 64")
+
+def test_bytes_parsing():
+    '''Properties with byte array values'''
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	a = [ ];
+	b = [ 12 34 ];
+	c = [ 1234 ];
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a;
+	b = [ 12 34 ];
+	c = [ 12 34 ];
+};
+""")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	a = [ 123 ];
+};
+""",
+":4 (column 10): parse error: expected two-digit byte or ']'")
+
+def test_string_parsing():
+    '''Properties with string values'''
+
+    verify_parse(r"""
+/dts-v1/;
+
+/ {
+	a = "";
+	b = "ABC";
+	c = "\\\"\xab\377\a\b\t\n\v\f\r";
+};
+""",
+r"""
+/dts-v1/;
+
+/ {
+	a = "";
+	b = "ABC";
+	c = "\\\"\xab\xff\a\b\t\n\v\f\r";
+};
+""")
+
+    verify_error_endswith(r"""
+/dts-v1/;
+
+/ {
+	a = "\400";
+};
+""",
+":4 (column 6): parse error: octal escape out of range (> 255)")
+
+def test_char_literal_parsing():
+    '''Properties with character literal values'''
+
+    verify_parse(r"""
+/dts-v1/;
+
+/ {
+	a = < '\'' >;
+	b = < '\x12' >;
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a = < 0x27 >;
+	b = < 0x12 >;
+};
+""")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	// Character literals are not allowed at the top level
+	a = 'x';
+};
+""",
+":5 (column 6): parse error: malformed value")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	a = < '' >;
+};
+""",
+":4 (column 7): parse error: character literals must be length 1")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	a = < '12' >;
+};
+""",
+":4 (column 7): parse error: character literals must be length 1")
+
+def test_incbin(tmp_path):
+    '''Test /incbin/, an undocumented feature that allows for
+    binary file inclusion.
+
+    https://github.com/dgibson/dtc/commit/e37ec7d5889fa04047daaa7a4ff55150ed7954d4'''
+
+    open(tmp_path / "tmp_bin", "wb").write(b"\00\01\02\03")
+
+    verify_parse(f"""
+/dts-v1/;
+
+/ {{
+	a = /incbin/ ("{tmp_path}/tmp_bin");
+	b = /incbin/ ("{tmp_path}/tmp_bin", 1, 1);
+	c = /incbin/ ("{tmp_path}/tmp_bin", 1, 2);
+}};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a = [ 00 01 02 03 ];
+	b = [ 01 ];
+	c = [ 01 02 ];
+};
+""")
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	a = /incbin/ ("tmp_bin");
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a = [ 00 01 02 03 ];
+};
+""",
+                 include_path=(tmp_path,))
+
+    verify_error_endswith(r"""
+/dts-v1/;
+
+/ {
+	a = /incbin/ ("missing");
+};
+""",
+":4 (column 25): parse error: 'missing' could not be found")
+
+def test_node_merging():
+    '''
+    Labels and properties specified for the same node in different
+    statements should be merged.
+    '''
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	l1: l2: l1: foo {
+		foo1 = [ 01 ];
+		l4: l5: bar {
+			bar1 = [ 01 ];
+		};
+	};
+};
+
+l3: &l1 {
+	foo2 = [ 02 ];
+	l6: l7: bar {
+		bar2 = [ 02 ];
+	};
+};
+
+&l3 {
+	foo3 = [ 03 ];
+};
+
+&{/foo} {
+	foo4 = [ 04 ];
+};
+
+&{/foo/bar} {
+	bar3 = [ 03 ];
+	l8: baz {};
+};
+
+/ {
+};
+
+/ {
+	top = [ 01 ];
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	top = [ 01 ];
+	l1: l2: l3: foo {
+		foo1 = [ 01 ];
+		foo2 = [ 02 ];
+		foo3 = [ 03 ];
+		foo4 = [ 04 ];
+		l4: l5: l6: l7: bar {
+			bar1 = [ 01 ];
+			bar2 = [ 02 ];
+			bar3 = [ 03 ];
+			l8: baz {
+			};
+		};
+	};
+};
+""")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+};
+
+&missing {
+};
+""",
+":6 (column 1): parse error: undefined node label 'missing'")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+};
+
+&{foo} {
+};
+""",
+":6 (column 1): parse error: node path 'foo' does not start with '/'")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+};
+
+&{/foo} {
+};
+""",
+":6 (column 1): parse error: component 'foo' in path '/foo' does not exist")
+
+def test_property_labels():
+    '''Like nodes, properties can have labels too.'''
+
+    def verify_label2prop(label, expected):
+        actual = dt.label2prop[label].name
+        assert actual == expected, f"label '{label}' mapped to wrong property"
+
+    dt = verify_parse("""
+/dts-v1/;
+
+/ {
+	a;
+	b;
+	l2: c;
+	l4: l5: l5: l4: d = < 0 >;
+};
+
+/ {
+	l1: b;
+	l3: c;
+	l6: d;
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a;
+	l1: b;
+	l2: l3: c;
+	l4: l5: l6: d = < 0x0 >;
+};
+""")
+
+    verify_label2prop("l1", "b")
+    verify_label2prop("l2", "c")
+    verify_label2prop("l3", "c")
+    verify_label2prop("l4", "d")
+    verify_label2prop("l5", "d")
+    verify_label2prop("l6", "d")
+
+def test_property_offset_labels():
+    '''
+    It's possible to give labels to data at nonnegative byte offsets
+    within a property value.
+    '''
+
+    def verify_label2offset(label, expected_prop, expected_offset):
+        actual_prop, actual_offset = dt.label2prop_offset[label]
+        actual_prop = actual_prop.name
+        assert (actual_prop, actual_offset) == \
+            (expected_prop, expected_offset), \
+            f"label '{label}' maps to wrong offset or property"
+
+    dt = verify_parse("""
+/dts-v1/;
+
+/ {
+	a = l01: l02: < l03: &node l04: l05: 2 l06: >,
+            l07: l08: [ l09: 03 l10: l11: 04 l12: l13: ] l14:, "A";
+
+	b = < 0 > l23: l24:;
+
+	node: node {
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a = l01: l02: < l03: &node l04: l05: 0x2 l06: l07: l08: >, [ l09: 03 l10: l11: 04 l12: l13: l14: ], "A";
+	b = < 0x0 l23: l24: >;
+	node: node {
+		phandle = < 0x1 >;
+	};
+};
+""")
+
+    verify_label2offset("l01", "a", 0)
+    verify_label2offset("l02", "a", 0)
+    verify_label2offset("l04", "a", 4)
+    verify_label2offset("l05", "a", 4)
+    verify_label2offset("l06", "a", 8)
+    verify_label2offset("l09", "a", 8)
+    verify_label2offset("l10", "a", 9)
+
+    verify_label2offset("l23", "b", 4)
+    verify_label2offset("l24", "b", 4)
+
+def test_unit_addr():
+    '''Node unit addresses must be correctly extracted from their names.'''
+
+    def verify_unit_addr(path, expected):
+        node = dt.get_node(path)
+        assert node.unit_addr == expected, \
+            f"{node!r} has unexpected unit address"
+
+    dt = verify_parse("""
+/dts-v1/;
+
+/ {
+	no-unit-addr {
+	};
+
+	unit-addr@ABC {
+	};
+
+	unit-addr-non-numeric@foo-bar {
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	no-unit-addr {
+	};
+	unit-addr@ABC {
+	};
+	unit-addr-non-numeric@foo-bar {
+	};
+};
+""")
+
+    verify_unit_addr("/no-unit-addr", "")
+    verify_unit_addr("/unit-addr@ABC", "ABC")
+    verify_unit_addr("/unit-addr-non-numeric@foo-bar", "foo-bar")
+
+def test_node_path_references():
+    '''Node phandles may be specified using a reference to the node's path.'''
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	a = &label;
+	b = [ 01 ], &label;
+	c = [ 01 ], &label, <2>;
+	d = &{/abc};
+	label: abc {
+		e = &label;
+		f = &{/abc};
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	a = &label;
+	b = [ 01 ], &label;
+	c = [ 01 ], &label, < 0x2 >;
+	d = &{/abc};
+	label: abc {
+		e = &label;
+		f = &{/abc};
+	};
+};
+""")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	sub {
+		x = &missing;
+	};
+};
+""",
+"/sub: undefined node label 'missing'")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	sub {
+		x = &{/sub/missing};
+	};
+};
+""",
+"/sub: component 'missing' in path '/sub/missing' does not exist")
+
+def test_phandles():
+    '''Various tests related to phandles.'''
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	x = < &a &{/b} &c >;
+
+	dummy1 {
+		phandle = < 1 >;
+	};
+
+	dummy2 {
+		phandle = < 3 >;
+	};
+
+	a: a {
+	};
+
+	b {
+	};
+
+	c: c {
+		phandle = < 0xFF >;
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = < &a &{/b} &c >;
+	dummy1 {
+		phandle = < 0x1 >;
+	};
+	dummy2 {
+		phandle = < 0x3 >;
+	};
+	a: a {
+		phandle = < 0x2 >;
+	};
+	b {
+		phandle = < 0x4 >;
+	};
+	c: c {
+		phandle = < 0xff >;
+	};
+};
+""")
+
+    # Check that a node can be assigned a phandle to itself. This just forces a
+    # phandle to be allocated on it. The C tools support this too.
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	dummy {
+		phandle = < 1 >;
+	};
+
+	a {
+                foo: phandle = < &{/a} >;
+	};
+
+	label: b {
+                bar: phandle = < &label >;
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	dummy {
+		phandle = < 0x1 >;
+	};
+	a {
+		foo: phandle = < &{/a} >;
+	};
+	label: b {
+		bar: phandle = < &label >;
+	};
+};
+""")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	sub {
+		x = < &missing >;
+	};
+};
+""",
+"/sub: undefined node label 'missing'")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	a: sub {
+		x = /bits/ 16 < &a >;
+	};
+};
+""",
+":5 (column 19): parse error: phandle references are only allowed in arrays with 32-bit elements")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo {
+		phandle = [ 00 ];
+	};
+};
+""",
+"/foo: bad phandle length (1), expected 4 bytes")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo {
+		phandle = < 0 >;
+	};
+};
+""",
+"/foo: bad value 0x00000000 for phandle")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo {
+		phandle = < (-1) >;
+	};
+};
+""",
+"/foo: bad value 0xffffffff for phandle")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo {
+		phandle = < 17 >;
+	};
+
+	bar {
+		phandle = < 17 >;
+	};
+};
+""",
+"/bar: duplicated phandle 0x11 (seen before at /foo)")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo {
+		phandle = < &{/bar} >;
+	};
+
+	bar {
+	};
+};
+""",
+"/foo: phandle refers to another node")
+
+def test_phandle2node():
+    '''Test the phandle2node dict in a dt instance.'''
+
+    def verify_phandle2node(prop, offset, expected_name):
+        phandle = dtlib.to_num(dt.root.props[prop].value[offset:offset + 4])
+        actual_name = dt.phandle2node[phandle].name
+
+        assert actual_name == expected_name, \
+            f"'{prop}' is a phandle for the wrong thing"
+
+    dt = parse("""
+/dts-v1/;
+
+/ {
+	phandle_ = < &{/node1} 0 1 >;
+	phandles = < 0 &{/node2} 1 &{/node3} >;
+
+	node1 {
+		phandle = < 123 >;
+	};
+
+	node2 {
+	};
+
+	node3 {
+	};
+};
+""")
+
+    verify_phandle2node("phandle_", 0, "node1")
+    verify_phandle2node("phandles", 4, "node2")
+    verify_phandle2node("phandles", 12, "node3")
+
+def test_mixed_assign():
+    '''Test mixed value type assignments'''
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	x = /bits/ 8 < 0xFF 0xFF >,
+	    &abc,
+	    < 0xFF &abc 0xFF &abc >,
+	    &abc,
+	    [ FF FF ],
+	    "abc";
+
+	abc: abc {
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = [ FF FF ], &abc, < 0xff &abc 0xff &abc >, &abc, [ FF FF ], "abc";
+	abc: abc {
+		phandle = < 0x1 >;
+	};
+};
+""")
+
+def test_deletion():
+    '''Properties and nodes may be deleted from the tree.'''
+
+    # Test property deletion
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	keep = < 1 >;
+	delete = < &sub >, &sub;
+	/delete-property/ missing;
+	/delete-property/ delete;
+	sub: sub {
+		y = < &sub >, &sub;
+	};
+};
+
+&sub {
+	/delete-property/ y;
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	keep = < 0x1 >;
+	sub: sub {
+	};
+};
+""")
+
+    # Test node deletion
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	sub1 {
+		x = < 1 >;
+		sub2 {
+			x = < &sub >, &sub;
+		};
+		/delete-node/ sub2;
+	};
+
+	sub3: sub3 {
+		x = < &sub >, &sub;
+	};
+
+	sub4 {
+		x = < &sub >, &sub;
+	};
+};
+
+/delete-node/ &sub3;
+/delete-node/ &{/sub4};
+""",
+"""
+/dts-v1/;
+
+/ {
+	sub1 {
+		x = < 0x1 >;
+	};
+};
+""")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+};
+
+/delete-node/ &missing;
+""",
+":6 (column 15): parse error: undefined node label 'missing'")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/delete-node/ {
+""",
+":3 (column 15): parse error: expected label (&foo) or path (&{/foo/bar}) reference")
+
+def test_include_curdir(tmp_path):
+    '''Verify that /include/ (which is handled in the lexer) searches the
+    current directory'''
+
+    with temporary_chdir(tmp_path):
+        with open("same-dir-1", "w") as f:
+            f.write("""
+    x = [ 00 ];
+    /include/ "same-dir-2"
+""")
+        with open("same-dir-2", "w") as f:
+            f.write("""
+    y = [ 01 ];
+    /include/ "same-dir-3"
+""")
+        with open("same-dir-3", "w") as f:
+            f.write("""
+    z = [ 02 ];
+""")
+        with open("test.dts", "w") as f:
+            f.write("""
+/dts-v1/;
+
+/ {
+	/include/ "same-dir-1"
+};
+""")
+        dt = dtlib.DT("test.dts")
+        assert str(dt) == """
+/dts-v1/;
+
+/ {
+	x = [ 00 ];
+	y = [ 01 ];
+	z = [ 02 ];
+};
+"""[1:-1]
+
+def test_include_is_lexical(tmp_path):
+    '''/include/ is done in the lexer, which means that property
+    definitions can span multiple included files in different
+    directories.'''
+
+    with open(tmp_path / "tmp2.dts", "w") as f:
+        f.write("""
+/dts-v1/;
+/ {
+""")
+    with open(tmp_path / "tmp3.dts", "w") as f:
+        f.write("""
+    x = <1>;
+""")
+
+    subdir_1 = tmp_path / "subdir-1"
+    subdir_1.mkdir()
+    with open(subdir_1 / "via-include-path-1", "w") as f:
+        f.write("""
+      = /include/ "via-include-path-2"
+""")
+
+    subdir_2 = tmp_path / "subdir-2"
+    subdir_2.mkdir()
+    with open(subdir_2 / "via-include-path-2", "w") as f:
+        f.write("""
+        <2>;
+};
+""")
+
+    with open(tmp_path / "test.dts", "w") as test_dts:
+        test_dts.write("""
+/include/ "tmp2.dts"
+/include/ "tmp3.dts"
+y /include/ "via-include-path-1"
+""")
+
+    with temporary_chdir(tmp_path):
+        dt = dtlib.DT("test.dts", include_path=(subdir_1, subdir_2))
+    expected_dt = """
+/dts-v1/;
+
+/ {
+	x = < 0x1 >;
+	y = < 0x2 >;
+};
+"""[1:-1]
+    assert str(dt) == expected_dt
+
+def test_include_misc(tmp_path):
+    '''Miscellaneous /include/ tests.'''
+
+    # Missing includes should error out.
+
+    verify_error_endswith("""
+/include/ "missing"
+""",
+":1 (column 1): parse error: 'missing' could not be found")
+
+    # Verify that an error in an included file points to the right location
+
+    with temporary_chdir(tmp_path):
+        with open("tmp2.dts", "w") as f:
+            f.write("""\
+
+
+  x
+""")
+        with open("tmp.dts", "w") as f:
+            f.write("""
+
+
+/include/ "tmp2.dts"
+""")
+        with pytest.raises(dtlib.DTError) as e:
+            dtlib.DT("tmp.dts")
+
+        assert str(e.value) == \
+            "tmp2.dts:3 (column 3): parse error: expected '/dts-v1/;' at start of file"
+
+def test_include_recursion(tmp_path):
+    '''Test recursive /include/ detection'''
+
+    with temporary_chdir(tmp_path):
+        with open("tmp2.dts", "w") as f:
+            f.write('/include/ "tmp3.dts"\n')
+        with open("tmp3.dts", "w") as f:
+            f.write('/include/ "tmp.dts"\n')
+
+        with open("tmp.dts", "w") as f:
+            f.write('/include/ "tmp2.dts"\n')
+        with pytest.raises(dtlib.DTError) as e:
+            dtlib.DT("tmp.dts")
+
+        expected_err = """\
+tmp3.dts:1 (column 1): parse error: recursive /include/:
+tmp.dts:1 ->
+tmp2.dts:1 ->
+tmp3.dts:1 ->
+tmp.dts"""
+        assert str(e.value) == expected_err
+
+        with open("tmp.dts", "w") as f:
+            f.write('/include/ "tmp.dts"\n')
+        with pytest.raises(dtlib.DTError) as e:
+            dtlib.DT("tmp.dts")
+        expected_err = """\
+tmp.dts:1 (column 1): parse error: recursive /include/:
+tmp.dts:1 ->
+tmp.dts"""
+        assert str(e.value) == expected_err
+
+def test_omit_if_no_ref():
+    '''The /omit-if-no-ref/ marker is a bit of undocumented
+    dtc magic that removes a node from the tree if it isn't
+    referred to elsewhere.
+
+    https://elinux.org/Device_Tree_Source_Undocumented
+    '''
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	x = < &{/referenced} >, &referenced2;
+
+	/omit-if-no-ref/ referenced {
+	};
+
+	referenced2: referenced2 {
+	};
+
+	/omit-if-no-ref/ unreferenced {
+	};
+
+	l1: /omit-if-no-ref/ unreferenced2 {
+	};
+
+	/omit-if-no-ref/ l2: unreferenced3 {
+	};
+
+	unreferenced4: unreferenced4 {
+	};
+
+	unreferenced5 {
+	};
+};
+
+/omit-if-no-ref/ &referenced2;
+/omit-if-no-ref/ &unreferenced4;
+/omit-if-no-ref/ &{/unreferenced5};
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = < &{/referenced} >, &referenced2;
+	referenced {
+		phandle = < 0x1 >;
+	};
+	referenced2: referenced2 {
+	};
+};
+""")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	/omit-if-no-ref/ x = "";
+};
+""",
+":4 (column 21): parse error: /omit-if-no-ref/ can only be used on nodes")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	/omit-if-no-ref/ x;
+};
+""",
+":4 (column 20): parse error: /omit-if-no-ref/ can only be used on nodes")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	/omit-if-no-ref/ {
+	};
+};
+""",
+":4 (column 19): parse error: expected node or property name")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	/omit-if-no-ref/ = < 0 >;
+};
+""",
+":4 (column 19): parse error: expected node or property name")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+};
+
+/omit-if-no-ref/ &missing;
+""",
+":6 (column 18): parse error: undefined node label 'missing'")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/omit-if-no-ref/ {
+""",
+":3 (column 18): parse error: expected label (&foo) or path (&{/foo/bar}) reference")
+
+def test_expr():
+    '''Property values may contain expressions.'''
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	ter1        = < (0 ? 1 : 0 ? 2 : 3) >;
+	ter2        = < (0 ? 1 : 1 ? 2 : 3) >;
+	ter3        = < (1 ? 1 : 0 ? 2 : 3) >;
+	ter4        = < (1 ? 1 : 1 ? 2 : 3) >;
+	or1         = < (0 || 0) >;
+	or2         = < (0 || 1) >;
+	or3         = < (1 || 0) >;
+	or4         = < (1 || 1) >;
+	and1        = < (0 && 0) >;
+	and2        = < (0 && 1) >;
+	and3        = < (1 && 0) >;
+	and4        = < (1 && 1) >;
+	bitor       = < (1 | 2) >;
+	bitxor      = < (7 ^ 2) >;
+	bitand      = < (3 & 6) >;
+	eq1         = < (1 == 0) >;
+	eq2         = < (1 == 1) >;
+	neq1        = < (1 != 0) >;
+	neq2        = < (1 != 1) >;
+	lt1         = < (1 < 2) >;
+	lt2         = < (2 < 2) >;
+	lt3         = < (3 < 2) >;
+	lteq1       = < (1 <= 2) >;
+	lteq2       = < (2 <= 2) >;
+	lteq3       = < (3 <= 2) >;
+	gt1         = < (1 > 2) >;
+	gt2         = < (2 > 2) >;
+	gt3         = < (3 > 2) >;
+	gteq1       = < (1 >= 2) >;
+	gteq2       = < (2 >= 2) >;
+	gteq3       = < (3 >= 2) >;
+	lshift      = < (2 << 3) >;
+	rshift      = < (16 >> 3) >;
+	add         = < (3 + 4) >;
+	sub         = < (7 - 4) >;
+	mul         = < (3 * 4) >;
+	div         = < (11 / 3) >;
+	mod         = < (11 % 3) >;
+	unary_minus = < (-3) >;
+	bitnot      = < (~1) >;
+	not0        = < (!-1) >;
+	not1        = < (!0) >;
+	not2        = < (!1) >;
+	not3        = < (!2) >;
+	nest        = < (((--3) + (-2)) * (--(-2))) >;
+	char_lits   = < ('a' + 'b') >;
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	ter1 = < 0x3 >;
+	ter2 = < 0x2 >;
+	ter3 = < 0x1 >;
+	ter4 = < 0x1 >;
+	or1 = < 0x0 >;
+	or2 = < 0x1 >;
+	or3 = < 0x1 >;
+	or4 = < 0x1 >;
+	and1 = < 0x0 >;
+	and2 = < 0x0 >;
+	and3 = < 0x0 >;
+	and4 = < 0x1 >;
+	bitor = < 0x3 >;
+	bitxor = < 0x5 >;
+	bitand = < 0x2 >;
+	eq1 = < 0x0 >;
+	eq2 = < 0x1 >;
+	neq1 = < 0x1 >;
+	neq2 = < 0x0 >;
+	lt1 = < 0x1 >;
+	lt2 = < 0x0 >;
+	lt3 = < 0x0 >;
+	lteq1 = < 0x1 >;
+	lteq2 = < 0x1 >;
+	lteq3 = < 0x0 >;
+	gt1 = < 0x0 >;
+	gt2 = < 0x0 >;
+	gt3 = < 0x1 >;
+	gteq1 = < 0x0 >;
+	gteq2 = < 0x1 >;
+	gteq3 = < 0x1 >;
+	lshift = < 0x10 >;
+	rshift = < 0x2 >;
+	add = < 0x7 >;
+	sub = < 0x3 >;
+	mul = < 0xc >;
+	div = < 0x3 >;
+	mod = < 0x2 >;
+	unary_minus = < 0xfffffffd >;
+	bitnot = < 0xfffffffe >;
+	not0 = < 0x0 >;
+	not1 = < 0x1 >;
+	not2 = < 0x0 >;
+	not3 = < 0x0 >;
+	nest = < 0xfffffffe >;
+	char_lits = < 0xc3 >;
+};
+""")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	a = < (1/(-1 + 1)) >;
+};
+""",
+":4 (column 18): parse error: division by zero")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	a = < (1%0) >;
+};
+""",
+":4 (column 11): parse error: division by zero")
+
+def test_comment_removal():
+    '''Comments should be removed when round-tripped to a str.'''
+
+    verify_parse("""
+/**//dts-v1//**/;//
+//
+// foo
+/ /**/{// foo
+x/**/=/*
+foo
+*/</**/1/***/>/****/;/**/}/*/**/;
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = < 0x1 >;
+};
+""")
+
+def verify_path_is(path, node_name, dt):
+    '''Verify 'node.name' matches 'node_name' in 'dt'.'''
+
+    try:
+        node = dt.get_node(path)
+        assert node.name == node_name, f'unexpected path {path}'
+    except dtlib.DTError:
+        assert False, f'no node found for path {path}'
+
+def verify_path_error(path, msg, dt):
+    '''Verify that an attempt to get node 'path' from 'dt' raises
+    a DTError whose str is 'msg'.'''
+
+    with pytest.raises(dtlib.DTError) as e:
+        dt.get_node(path)
+    assert str(e.value) == msg, f"'{path}' gives the wrong error"
+
+def test_get_node():
+    '''Test DT.get_node().'''
+
+    dt = parse("""
+/dts-v1/;
+
+/ {
+	foo {
+		bar {
+		};
+	};
+
+	baz {
+	};
+};
+""")
+
+    verify_path_is("/", "/", dt)
+    verify_path_is("//", "/", dt)
+    verify_path_is("///", "/", dt)
+    verify_path_is("/foo", "foo", dt)
+    verify_path_is("//foo", "foo", dt)
+    verify_path_is("///foo", "foo", dt)
+    verify_path_is("/foo/bar", "bar", dt)
+    verify_path_is("//foo//bar", "bar", dt)
+    verify_path_is("///foo///bar", "bar", dt)
+    verify_path_is("/baz", "baz", dt)
+
+    verify_path_error(
+        "",
+        "no alias '' found -- did you forget the leading '/' in the node path?",
+        dt)
+    verify_path_error(
+        "missing",
+        "no alias 'missing' found -- did you forget the leading '/' in the node path?",
+        dt)
+    verify_path_error(
+        "/missing",
+        "component 'missing' in path '/missing' does not exist",
+        dt)
+    verify_path_error(
+        "/foo/missing",
+        "component 'missing' in path '/foo/missing' does not exist",
+        dt)
+
+    def verify_path_exists(path):
+        assert dt.has_node(path), f"path '{path}' does not exist"
+
+    def verify_path_missing(path):
+        assert not dt.has_node(path), f"path '{path}' exists"
+
+    verify_path_exists("/")
+    verify_path_exists("/foo")
+    verify_path_exists("/foo/bar")
+
+    verify_path_missing("/missing")
+    verify_path_missing("/foo/missing")
+
+def test_aliases():
+    '''Test /aliases'''
+
+    dt = parse("""
+/dts-v1/;
+
+/ {
+	aliases {
+		alias1 = &l1;
+		alias2 = &l2;
+		alias3 = &{/sub/node3};
+		alias4 = &{/node4};
+	};
+
+	l1: node1 {
+	};
+
+	l2: node2 {
+	};
+
+	sub {
+		node3 {
+		};
+	};
+
+	node4 {
+		node5 {
+		};
+	};
+};
+""")
+
+    def verify_alias_target(alias, node_name):
+        verify_path_is(alias, node_name, dt)
+        assert alias in dt.alias2node
+        assert dt.alias2node[alias].name == node_name, f"bad result for {alias}"
+
+    verify_alias_target("alias1", "node1")
+    verify_alias_target("alias2", "node2")
+    verify_alias_target("alias3", "node3")
+    verify_path_is("alias4/node5", "node5", dt)
+
+    verify_path_error(
+        "alias4/node5/node6",
+        "component 'node6' in path 'alias4/node5/node6' does not exist",
+        dt)
+
+    verify_error_matches("""
+/dts-v1/;
+
+/ {
+	aliases {
+		a = [ 00 ];
+	};
+};
+""",
+"expected property 'a' on /aliases in .*" +
+re.escape("to be assigned with either 'a = &foo' or 'a = \"/path/to/node\"', not 'a = [ 00 ];'"))
+
+    verify_error_matches(r"""
+/dts-v1/;
+
+/ {
+	aliases {
+		a = "\xFF";
+	};
+};
+""",
+re.escape(r"value of property 'a' (b'\xff\x00') on /aliases in ") +
+".* is not valid UTF-8")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	aliases {
+		A = "/aliases";
+	};
+};
+""",
+"/aliases: alias property name 'A' should include only characters from [0-9a-z-]")
+
+    verify_error_matches(r"""
+/dts-v1/;
+
+/ {
+	aliases {
+		a = "/missing";
+	};
+};
+""",
+"property 'a' on /aliases in .* points to the non-existent node \"/missing\"")
+
+def test_prop_type():
+    '''Test Property.type'''
+
+    def verify_type(prop, expected):
+        actual = dt.root.props[prop].type
+        assert actual == expected, f'{prop} has wrong type'
+
+    dt = parse("""
+/dts-v1/;
+
+/ {
+	empty;
+	bytes1 = [ ];
+	bytes2 = [ 01 ];
+	bytes3 = [ 01 02 ];
+	bytes4 = foo: [ 01 bar: 02 ];
+	bytes5 = /bits/ 8 < 1 2 3 >;
+	num = < 1 >;
+	nums1 = < >;
+	nums2 = < >, < >;
+	nums3 = < 1 2 >;
+	nums4 = < 1 2 >, < 3 >, < 4 >;
+	string = "foo";
+	strings = "foo", "bar";
+	path1 = &node;
+	path2 = &{/node};
+	phandle1 = < &node >;
+	phandle2 = < &{/node} >;
+	phandles1 = < &node &node >;
+	phandles2 = < &node >, < &node >;
+	phandle-and-nums-1 = < &node 1 >;
+	phandle-and-nums-2 = < &node 1 2 &node 3 4 >;
+	phandle-and-nums-3 = < &node 1 2 >, < &node 3 4 >;
+	compound1 = < 1 >, [ 02 ];
+	compound2 = "foo", < >;
+
+	node: node {
+	};
+};
+""")
+
+    verify_type("empty", dtlib.Type.EMPTY)
+    verify_type("bytes1", dtlib.Type.BYTES)
+    verify_type("bytes2", dtlib.Type.BYTES)
+    verify_type("bytes3", dtlib.Type.BYTES)
+    verify_type("bytes4", dtlib.Type.BYTES)
+    verify_type("bytes5", dtlib.Type.BYTES)
+    verify_type("num", dtlib.Type.NUM)
+    verify_type("nums1", dtlib.Type.NUMS)
+    verify_type("nums2", dtlib.Type.NUMS)
+    verify_type("nums3", dtlib.Type.NUMS)
+    verify_type("nums4", dtlib.Type.NUMS)
+    verify_type("string", dtlib.Type.STRING)
+    verify_type("strings", dtlib.Type.STRINGS)
+    verify_type("phandle1", dtlib.Type.PHANDLE)
+    verify_type("phandle2", dtlib.Type.PHANDLE)
+    verify_type("phandles1", dtlib.Type.PHANDLES)
+    verify_type("phandles2", dtlib.Type.PHANDLES)
+    verify_type("phandle-and-nums-1", dtlib.Type.PHANDLES_AND_NUMS)
+    verify_type("phandle-and-nums-2", dtlib.Type.PHANDLES_AND_NUMS)
+    verify_type("phandle-and-nums-3", dtlib.Type.PHANDLES_AND_NUMS)
+    verify_type("path1", dtlib.Type.PATH)
+    verify_type("path2", dtlib.Type.PATH)
+    verify_type("compound1", dtlib.Type.COMPOUND)
+    verify_type("compound2", dtlib.Type.COMPOUND)
+
+def test_prop_type_casting():
+    '''Test Property.to_{num,nums,string,strings,node}()'''
+
+    dt = parse(r"""
+/dts-v1/;
+
+/ {
+	u = < 1 >;
+	s = < 0xFFFFFFFF >;
+	u8 = /bits/ 8 < 1 >;
+	u16 = /bits/ 16 < 1 2 >;
+	u64 = /bits/ 64 < 1 >;
+        bytes = [ 01 02 03 ];
+	empty;
+	zero = < >;
+	two_u = < 1 2 >;
+	two_s = < 0xFFFFFFFF 0xFFFFFFFE >;
+	three_u = < 1 2 3 >;
+	three_u_split = < 1 >, < 2 >, < 3 >;
+	empty_string = "";
+	string = "foo\tbar baz";
+	invalid_string = "\xff";
+	strings = "foo", "bar", "baz";
+	invalid_strings = "foo", "\xff", "bar";
+	ref = <&{/target}>;
+	refs = <&{/target} &{/target2}>;
+	refs2 = <&{/target}>, <&{/target2}>;
+	path = &{/target};
+	manualpath = "/target";
+	missingpath = "/missing";
+
+	target {
+		phandle = < 100 >;
+	};
+
+	target2 {
+	};
+};
+""")
+
+    # Test Property.to_num()
+
+    def verify_to_num(prop, signed, expected):
+        signed_str = "a signed" if signed else "an unsigned"
+        actual = dt.root.props[prop].to_num(signed)
+        assert actual == expected, \
+            f"{prop} has bad {signed_str} numeric value"
+
+    def verify_to_num_error_matches(prop, expected_re):
+        with pytest.raises(dtlib.DTError) as e:
+            dt.root.props[prop].to_num()
+        actual_msg = str(e.value)
+        assert re.fullmatch(expected_re, actual_msg), \
+            f"'{prop}' to_num gives the wrong error: " \
+            f"actual message:\n{actual_msg!r}\n" \
+            f"does not match:\n{expected_re!r}"
+
+    verify_to_num("u", False, 1)
+    verify_to_num("u", True, 1)
+    verify_to_num("s", False, 0xFFFFFFFF)
+    verify_to_num("s", True, -1)
+
+    verify_to_num_error_matches(
+        "two_u",
+        "expected property 'two_u' on / in .* to be assigned with " +
+        re.escape("'two_u = < (number) >;', not 'two_u = < 0x1 0x2 >;'"))
+    verify_to_num_error_matches(
+        "u8",
+        "expected property 'u8' on / in .* to be assigned with " +
+        re.escape("'u8 = < (number) >;', not 'u8 = [ 01 ];'"))
+    verify_to_num_error_matches(
+        "u16",
+        "expected property 'u16' on / in .* to be assigned with " +
+        re.escape("'u16 = < (number) >;', not 'u16 = /bits/ 16 < 0x1 0x2 >;'"))
+    verify_to_num_error_matches(
+        "u64",
+        "expected property 'u64' on / in .* to be assigned with " +
+        re.escape("'u64 = < (number) >;', not 'u64 = /bits/ 64 < 0x1 >;'"))
+    verify_to_num_error_matches(
+        "string",
+        "expected property 'string' on / in .* to be assigned with " +
+        re.escape("'string = < (number) >;', not 'string = \"foo\\tbar baz\";'"))
+
+    # Test Property.to_nums()
+
+    def verify_to_nums(prop, signed, expected):
+        signed_str = "signed" if signed else "unsigned"
+        actual = dt.root.props[prop].to_nums(signed)
+        assert actual == expected, \
+            f"'{prop}' gives the wrong {signed_str} numbers"
+
+    def verify_to_nums_error_matches(prop, expected_re):
+        with pytest.raises(dtlib.DTError) as e:
+            dt.root.props[prop].to_nums()
+        assert re.fullmatch(expected_re, str(e.value)), \
+            f"'{prop}' to_nums gives the wrong error"
+
+    verify_to_nums("zero", False, [])
+    verify_to_nums("u", False, [1])
+    verify_to_nums("two_u", False, [1, 2])
+    verify_to_nums("two_u", True, [1, 2])
+    verify_to_nums("two_s", False, [0xFFFFFFFF, 0xFFFFFFFE])
+    verify_to_nums("two_s", True, [-1, -2])
+    verify_to_nums("three_u", False, [1, 2, 3])
+    verify_to_nums("three_u_split", False, [1, 2, 3])
+
+    verify_to_nums_error_matches(
+        "empty",
+        "expected property 'empty' on / in .* to be assigned with " +
+        re.escape("'empty = < (number) (number) ... >;', not 'empty;'"))
+    verify_to_nums_error_matches(
+        "string",
+        "expected property 'string' on / in .* to be assigned with " +
+        re.escape("'string = < (number) (number) ... >;', ") +
+        re.escape("not 'string = \"foo\\tbar baz\";'"))
+
+    # Test Property.to_bytes()
+
+    def verify_to_bytes(prop, expected):
+        actual = dt.root.props[prop].to_bytes()
+        assert actual == expected, f"'{prop}' gives the wrong bytes"
+
+    def verify_to_bytes_error_matches(prop, expected_re):
+        with pytest.raises(dtlib.DTError) as e:
+            dt.root.props[prop].to_bytes()
+        assert re.fullmatch(expected_re, str(e.value)), \
+            f"'{prop}' gives the wrong error"
+
+    verify_to_bytes("u8", b"\x01")
+    verify_to_bytes("bytes", b"\x01\x02\x03")
+
+    verify_to_bytes_error_matches(
+        "u16",
+        "expected property 'u16' on / in .* to be assigned with " +
+        re.escape("'u16 = [ (byte) (byte) ... ];', ") +
+        re.escape("not 'u16 = /bits/ 16 < 0x1 0x2 >;'"))
+    verify_to_bytes_error_matches(
+        "empty",
+        "expected property 'empty' on / in .* to be assigned with " +
+        re.escape("'empty = [ (byte) (byte) ... ];', not 'empty;'"))
+
+    # Test Property.to_string()
+
+    def verify_to_string(prop, expected):
+        actual = dt.root.props[prop].to_string()
+        assert actual == expected, f"'{prop}' to_string gives the wrong string"
+
+    def verify_to_string_error_matches(prop, expected_re):
+        with pytest.raises(dtlib.DTError) as e:
+            dt.root.props[prop].to_string()
+        assert re.fullmatch(expected_re, str(e.value)), \
+            f"'{prop}' gives the wrong error"
+
+    verify_to_string("empty_string", "")
+    verify_to_string("string", "foo\tbar baz")
+
+    verify_to_string_error_matches(
+        "u",
+        "expected property 'u' on / in .* to be assigned with " +
+        re.escape("'u = \"string\";', not 'u = < 0x1 >;'"))
+    verify_to_string_error_matches(
+        "strings",
+        "expected property 'strings' on / in .* to be assigned with " +
+        re.escape("'strings = \"string\";', ")+
+        re.escape("not 'strings = \"foo\", \"bar\", \"baz\";'"))
+    verify_to_string_error_matches(
+        "invalid_string",
+        re.escape(r"value of property 'invalid_string' (b'\xff\x00') on / ") +
+        "in .* is not valid UTF-8")
+
+    # Test Property.to_strings()
+
+    def verify_to_strings(prop, expected):
+        actual = dt.root.props[prop].to_strings()
+        assert actual == expected, f"'{prop}' to_strings gives the wrong value"
+
+    def verify_to_strings_error_matches(prop, expected_re):
+        with pytest.raises(dtlib.DTError) as e:
+            dt.root.props[prop].to_strings()
+        assert re.fullmatch(expected_re, str(e.value)), \
+            f"'{prop}' gives the wrong error"
+
+    verify_to_strings("empty_string", [""])
+    verify_to_strings("string", ["foo\tbar baz"])
+    verify_to_strings("strings", ["foo", "bar", "baz"])
+
+    verify_to_strings_error_matches(
+        "u",
+        "expected property 'u' on / in .* to be assigned with " +
+        re.escape("'u = \"string\", \"string\", ... ;', not 'u = < 0x1 >;'"))
+    verify_to_strings_error_matches(
+        "invalid_strings",
+        "value of property 'invalid_strings' " +
+        re.escape(r"(b'foo\x00\xff\x00bar\x00') on / in ") +
+        ".* is not valid UTF-8")
+
+    # Test Property.to_node()
+
+    def verify_to_node(prop, path):
+        actual = dt.root.props[prop].to_node().path
+        assert actual == path, f"'{prop}' points at wrong path"
+
+    def verify_to_node_error_matches(prop, expected_re):
+        with pytest.raises(dtlib.DTError) as e:
+            dt.root.props[prop].to_node()
+        assert re.fullmatch(expected_re, str(e.value)), \
+            f"'{prop} gives the wrong error"
+
+    verify_to_node("ref", "/target")
+
+    verify_to_node_error_matches(
+        "u",
+        "expected property 'u' on / in .* to be assigned with " +
+        re.escape("'u = < &foo >;', not 'u = < 0x1 >;'"))
+    verify_to_node_error_matches(
+        "string",
+        "expected property 'string' on / in .* to be assigned with " +
+        re.escape("'string = < &foo >;', not 'string = \"foo\\tbar baz\";'"))
+
+    # Test Property.to_nodes()
+
+    def verify_to_nodes(prop, paths):
+        actual = [node.path for node in dt.root.props[prop].to_nodes()]
+        assert actual == paths, f"'{prop} gives wrong node paths"
+
+    def verify_to_nodes_error_matches(prop, expected_re):
+        with pytest.raises(dtlib.DTError) as e:
+            dt.root.props[prop].to_nodes()
+        assert re.fullmatch(expected_re, str(e.value)), \
+            f"'{prop} gives wrong error"
+
+    verify_to_nodes("zero", [])
+    verify_to_nodes("ref", ["/target"])
+    verify_to_nodes("refs", ["/target", "/target2"])
+    verify_to_nodes("refs2", ["/target", "/target2"])
+
+    verify_to_nodes_error_matches(
+        "u",
+        "expected property 'u' on / in .* to be assigned with " +
+        re.escape("'u = < &foo &bar ... >;', not 'u = < 0x1 >;'"))
+    verify_to_nodes_error_matches(
+        "string",
+        "expected property 'string' on / in .* to be assigned with " +
+        re.escape("'string = < &foo &bar ... >;', ") +
+        re.escape("not 'string = \"foo\\tbar baz\";'"))
+
+    # Test Property.to_path()
+
+    def verify_to_path(prop, path):
+        actual = dt.root.props[prop].to_path().path
+        assert actual == path, f"'{prop} gives the wrong path"
+
+    def verify_to_path_error_matches(prop, expected_re):
+        with pytest.raises(dtlib.DTError) as e:
+            dt.root.props[prop].to_path()
+        assert re.fullmatch(expected_re, str(e.value)), \
+            f"'{prop} gives the wrong error"
+
+    verify_to_path("path", "/target")
+    verify_to_path("manualpath", "/target")
+
+    verify_to_path_error_matches(
+        "u",
+        "expected property 'u' on / in .* to be assigned with either " +
+        re.escape("'u = &foo' or 'u = \"/path/to/node\"', not 'u = < 0x1 >;'"))
+    verify_to_path_error_matches(
+        "missingpath",
+        "property 'missingpath' on / in .* points to the non-existent node "
+        '"/missing"')
+
+    # Test top-level to_num() and to_nums()
+
+    def verify_raw_to_num(fn, prop, length, signed, expected):
+        actual = fn(dt.root.props[prop].value, length, signed)
+        assert actual == expected, \
+            f"{fn.__name__}(<{prop}>, {length}, {signed}) gives wrong value"
+
+    def verify_raw_to_num_error(fn, data, length, msg):
+        with pytest.raises(dtlib.DTError) as e:
+            fn(data, length)
+        assert str(e.value) == msg, \
+            (f"{fn.__name__}() called with data='{data}', length='{length}' "
+             "gives the wrong error")
+
+    verify_raw_to_num(dtlib.to_num, "u", None, False, 1)
+    verify_raw_to_num(dtlib.to_num, "u", 4, False, 1)
+    verify_raw_to_num(dtlib.to_num, "s", None, False, 0xFFFFFFFF)
+    verify_raw_to_num(dtlib.to_num, "s", None, True, -1)
+    verify_raw_to_num(dtlib.to_nums, "empty", 4, False, [])
+    verify_raw_to_num(dtlib.to_nums, "u16", 2, False, [1, 2])
+    verify_raw_to_num(dtlib.to_nums, "two_s", 4, False, [0xFFFFFFFF, 0xFFFFFFFE])
+    verify_raw_to_num(dtlib.to_nums, "two_s", 4, True, [-1, -2])
+
+    verify_raw_to_num_error(dtlib.to_num, 0, 0, "'0' has type 'int', expected 'bytes'")
+    verify_raw_to_num_error(dtlib.to_num, b"", 0, "'length' must be greater than zero, was 0")
+    verify_raw_to_num_error(dtlib.to_num, b"foo", 2, "b'foo' is 3 bytes long, expected 2")
+    verify_raw_to_num_error(dtlib.to_nums, 0, 0, "'0' has type 'int', expected 'bytes'")
+    verify_raw_to_num_error(dtlib.to_nums, b"", 0, "'length' must be greater than zero, was 0")
+    verify_raw_to_num_error(dtlib.to_nums, b"foooo", 2, "b'foooo' is 5 bytes long, expected a length that's a a multiple of 2")
+
+def test_duplicate_labels():
+    '''
+    It is an error to duplicate labels in most conditions, but there
+    are some exceptions where it's OK.
+    '''
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	sub1 {
+		label: foo {
+		};
+	};
+
+	sub2 {
+		label: bar {
+		};
+	};
+};
+""",
+"Label 'label' appears on /sub1/foo and on /sub2/bar")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	sub {
+		label: foo {
+		};
+	};
+};
+/ {
+	sub {
+		label: bar {
+		};
+	};
+};
+""",
+"Label 'label' appears on /sub/bar and on /sub/foo")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo: a = < 0 >;
+	foo: node {
+	};
+};
+""",
+"Label 'foo' appears on /node and on property 'a' of node /")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo: a = < 0 >;
+	node {
+		foo: b = < 0 >;
+	};
+};
+""",
+"Label 'foo' appears on property 'a' of node / and on property 'b' of node /node")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo: a = foo: < 0 >;
+};
+""",
+"Label 'foo' appears in the value of property 'a' of node / and on property 'a' of node /")
+
+    # Giving the same label twice for the same node is fine
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	sub {
+		label: foo {
+		};
+	};
+};
+/ {
+
+	sub {
+		label: foo {
+		};
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	sub {
+		label: foo {
+		};
+	};
+};
+""")
+
+    # Duplicate labels are fine if one of the nodes is deleted
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	label: foo {
+	};
+	label: bar {
+	};
+};
+
+/delete-node/ &{/bar};
+""",
+"""
+/dts-v1/;
+
+/ {
+	label: foo {
+	};
+};
+""")
+
+    #
+    # Test overriding/deleting a property with references
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	x = &foo, < &foo >;
+	y = &foo, < &foo >;
+	foo: foo {
+	};
+};
+
+/ {
+	x = < 1 >;
+	/delete-property/ y;
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	x = < 0x1 >;
+	foo: foo {
+	};
+};
+""")
+
+    #
+    # Test self-referential node
+    #
+
+    verify_parse("""
+/dts-v1/;
+
+/ {
+	label: foo {
+		x = &{/foo}, &label, < &label >;
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	label: foo {
+		x = &{/foo}, &label, < &label >;
+		phandle = < 0x1 >;
+	};
+};
+""")
+
+    #
+    # Test /memreserve/
+    #
+
+    dt = verify_parse("""
+/dts-v1/;
+
+l1: l2: /memreserve/ (1 + 1) (2 * 2);
+/memreserve/ 0x100 0x200;
+
+/ {
+};
+""",
+"""
+/dts-v1/;
+
+l1: l2: /memreserve/ 0x0000000000000002 0x0000000000000004;
+/memreserve/ 0x0000000000000100 0x0000000000000200;
+
+/ {
+};
+""")
+
+    expected = [(["l1", "l2"], 2, 4), ([], 0x100, 0x200)]
+    assert dt.memreserves == expected
+
+    verify_error_endswith("""
+/dts-v1/;
+
+foo: / {
+};
+""",
+":3 (column 6): parse error: expected /memreserve/ after labels at beginning of file")
+
+def test_reprs():
+    '''Test the __repr__() functions.'''
+
+    dts = """
+/dts-v1/;
+
+/ {
+	x = < 0 >;
+	sub {
+		y = < 1 >;
+	};
+};
+"""
+
+    dt = parse(dts, include_path=("foo", "bar"))
+
+    assert re.fullmatch(r"DT\(filename='.*', include_path=.'foo', 'bar'.\)",
+                        repr(dt))
+    assert re.fullmatch("<Property 'x' at '/' in '.*'>",
+                        repr(dt.root.props["x"]))
+    assert re.fullmatch("<Node /sub in '.*'>",
+                        repr(dt.root.nodes["sub"]))
+
+    dt = parse(dts, include_path=iter(("foo", "bar")))
+
+    assert re.fullmatch(r"DT\(filename='.*', include_path=.'foo', 'bar'.\)",
+                        repr(dt))
+
+def test_names():
+    '''Tests for node/property names.'''
+
+    # The C tools disallow '@' in property names, but otherwise accept the same
+    # characters in node and property names. Emulate that instead of the DT spec
+    # (v0.2), which gives different characters for nodes and properties.
+    verify_parse(r"""
+/dts-v1/;
+
+/ {
+	// A leading \ is accepted but ignored in node/propert names
+	\aA0,._+*#?- = &_, &{/aA0,._+*#?@-};
+
+	// Names that overlap with operators and integer literals
+
+	+ = [ 00 ];
+	* = [ 02 ];
+	- = [ 01 ];
+	? = [ 03 ];
+	0 = [ 04 ];
+	0x123 = [ 05 ];
+
+	_: \aA0,._+*#?@- {
+	};
+
+	0 {
+	};
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+	aA0,._+*#?- = &_, &{/aA0,._+*#?@-};
+	+ = [ 00 ];
+	* = [ 02 ];
+	- = [ 01 ];
+	? = [ 03 ];
+	0 = [ 04 ];
+	0x123 = [ 05 ];
+	_: aA0,._+*#?@- {
+	};
+	0 {
+	};
+};
+""")
+
+    verify_error_endswith(r"""
+/dts-v1/;
+
+/ {
+	foo@3;
+};
+""",
+":4 (column 7): parse error: '@' is only allowed in node names")
+
+    verify_error_endswith(r"""
+/dts-v1/;
+
+/ {
+	foo@3 = < 0 >;
+};
+""",
+":4 (column 8): parse error: '@' is only allowed in node names")
+
+    verify_error_endswith(r"""
+/dts-v1/;
+
+/ {
+	foo@2@3 {
+	};
+};
+""",
+":4 (column 10): parse error: multiple '@' in node name")
+
+def test_dense_input():
+    '''
+    Test that a densely written DTS input round-trips to something
+    readable.
+    '''
+
+    verify_parse("""
+/dts-v1/;/{l1:l2:foo{l3:l4:bar{l5:x=l6:/bits/8<l7:1 l8:2>l9:,[03],"a";};};};
+""",
+"""
+/dts-v1/;
+
+/ {
+	l1: l2: foo {
+		l3: l4: bar {
+			l5: x = l6: [ l7: 01 l8: 02 l9: ], [ 03 ], "a";
+		};
+	};
+};
+""")
+
+def test_misc():
+    '''Test miscellaneous errors and non-errors.'''
+
+    verify_error_endswith("", ":1 (column 1): parse error: expected '/dts-v1/;' at start of file")
+
+    verify_error_endswith("""
+/dts-v1/;
+""",
+":2 (column 1): parse error: no root node defined")
+
+    verify_error_endswith("""
+/dts-v1/; /plugin/;
+""",
+":1 (column 11): parse error: /plugin/ is not supported")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+	foo: foo {
+	};
+};
+
+// Only one label supported before label references at the top level
+l1: l2: &foo {
+};
+""",
+":9 (column 5): parse error: expected label reference (&foo)")
+
+    verify_error_endswith("""
+/dts-v1/;
+
+/ {
+        foo: {};
+};
+""",
+":4 (column 14): parse error: expected node or property name")
+
+    # Multiple /dts-v1/ at the start of a file is fine
+    verify_parse("""
+/dts-v1/;
+/dts-v1/;
+
+/ {
+};
+""",
+"""
+/dts-v1/;
+
+/ {
+};
+""")
+
+def test_dangling_alias():
+    dt = parse('''
+/dts-v1/;
+
+/ {
+	aliases { foo = "/missing"; };
+};
+''', force=True)
+    assert dt.get_node('/aliases').props['foo'].to_string() == '/missing'
diff --git a/tools/dts/python-devicetree/tests/test_edtlib.py b/tools/dts/python-devicetree/tests/test_edtlib.py
new file mode 100644
index 0000000000000000000000000000000000000000..f570d4b9ef214793b8760118a76ac9482b3fd682
--- /dev/null
+++ b/tools/dts/python-devicetree/tests/test_edtlib.py
@@ -0,0 +1,533 @@
+# Copyright (c) 2019 Nordic Semiconductor ASA
+# SPDX-License-Identifier: BSD-3-Clause
+
+import contextlib
+import io
+from logging import WARNING
+import os
+from pathlib import Path
+
+import pytest
+
+from devicetree import edtlib
+
+# Test suite for edtlib.py.
+#
+# Run it using pytest (https://docs.pytest.org/en/stable/usage.html):
+#
+#   $ pytest testedtlib.py
+#
+# See the comment near the top of testdtlib.py for additional pytest advice.
+#
+# test.dts is the main test file. test-bindings/ and test-bindings-2/ has
+# bindings. The tests mostly use string comparisons via the various __repr__()
+# methods.
+
+HERE = os.path.dirname(__file__)
+
+@contextlib.contextmanager
+def from_here():
+    # Convenience hack to minimize diff from zephyr.
+    cwd = os.getcwd()
+    try:
+        os.chdir(HERE)
+        yield
+    finally:
+        os.chdir(cwd)
+
+def hpath(filename):
+    '''Convert 'filename' to the host path syntax.'''
+    return os.fspath(Path(filename))
+
+def test_warnings(caplog):
+    '''Tests for situations that should cause warnings.'''
+
+    with from_here(): edtlib.EDT("test.dts", ["test-bindings"])
+
+    enums_hpath = hpath('test-bindings/enums.yaml')
+    expected_warnings = [
+        f"'oldprop' is marked as deprecated in 'properties:' in {hpath('test-bindings/deprecated.yaml')} for node /test-deprecated.",
+        "unit address and first address in 'reg' (0x1) don't match for /reg-zero-size-cells/node",
+        "unit address and first address in 'reg' (0x5) don't match for /reg-ranges/parent/node",
+        "unit address and first address in 'reg' (0x30000000200000001) don't match for /reg-nested-ranges/grandparent/parent/node",
+        f"compatible 'enums' in binding '{enums_hpath}' has non-tokenizable enum for property 'string-enum': 'foo bar', 'foo_bar'",
+        f"compatible 'enums' in binding '{enums_hpath}' has enum for property 'tokenizable-lower-enum' that is only tokenizable in lowercase: 'bar', 'BAR'",
+    ]
+    assert caplog.record_tuples == [('devicetree.edtlib', WARNING, warning_message)
+                                    for warning_message in expected_warnings]
+
+def test_interrupts():
+    '''Tests for the interrupts property.'''
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+    filenames = {i: hpath(f'test-bindings/interrupt-{i}-cell.yaml')
+                 for i in range(1, 4)}
+
+    assert str(edt.get_node("/interrupt-parent-test/node").interrupts) == \
+        f"[<ControllerAndData, name: foo, controller: <Node /interrupt-parent-test/controller in 'test.dts', binding {filenames[3]}>, data: OrderedDict([('one', 1), ('two', 2), ('three', 3)])>, <ControllerAndData, name: bar, controller: <Node /interrupt-parent-test/controller in 'test.dts', binding {filenames[3]}>, data: OrderedDict([('one', 4), ('two', 5), ('three', 6)])>]"
+
+    assert str(edt.get_node("/interrupts-extended-test/node").interrupts) == \
+        f"[<ControllerAndData, controller: <Node /interrupts-extended-test/controller-0 in 'test.dts', binding {filenames[1]}>, data: OrderedDict([('one', 1)])>, <ControllerAndData, controller: <Node /interrupts-extended-test/controller-1 in 'test.dts', binding {filenames[2]}>, data: OrderedDict([('one', 2), ('two', 3)])>, <ControllerAndData, controller: <Node /interrupts-extended-test/controller-2 in 'test.dts', binding {filenames[3]}>, data: OrderedDict([('one', 4), ('two', 5), ('three', 6)])>]"
+
+    assert str(edt.get_node("/interrupt-map-test/node@0").interrupts) == \
+        f"[<ControllerAndData, controller: <Node /interrupt-map-test/controller-0 in 'test.dts', binding {filenames[1]}>, data: OrderedDict([('one', 0)])>, <ControllerAndData, controller: <Node /interrupt-map-test/controller-1 in 'test.dts', binding {filenames[2]}>, data: OrderedDict([('one', 0), ('two', 1)])>, <ControllerAndData, controller: <Node /interrupt-map-test/controller-2 in 'test.dts', binding {filenames[3]}>, data: OrderedDict([('one', 0), ('two', 0), ('three', 2)])>]"
+
+    assert str(edt.get_node("/interrupt-map-test/node@1").interrupts) == \
+        f"[<ControllerAndData, controller: <Node /interrupt-map-test/controller-0 in 'test.dts', binding {filenames[1]}>, data: OrderedDict([('one', 3)])>, <ControllerAndData, controller: <Node /interrupt-map-test/controller-1 in 'test.dts', binding {filenames[2]}>, data: OrderedDict([('one', 0), ('two', 4)])>, <ControllerAndData, controller: <Node /interrupt-map-test/controller-2 in 'test.dts', binding {filenames[3]}>, data: OrderedDict([('one', 0), ('two', 0), ('three', 5)])>]"
+
+    assert str(edt.get_node("/interrupt-map-bitops-test/node@70000000E").interrupts) == \
+        f"[<ControllerAndData, controller: <Node /interrupt-map-bitops-test/controller in 'test.dts', binding {filenames[2]}>, data: OrderedDict([('one', 3), ('two', 2)])>]"
+
+def test_reg():
+    '''Tests for the regs property'''
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+
+    assert str(edt.get_node("/reg-zero-address-cells/node").regs) == \
+        "[<Register, size: 0x1>, <Register, size: 0x2>]"
+
+    assert str(edt.get_node("/reg-zero-size-cells/node").regs) == \
+        "[<Register, addr: 0x1>, <Register, addr: 0x2>]"
+
+    assert str(edt.get_node("/reg-ranges/parent/node").regs) == \
+        "[<Register, addr: 0x5, size: 0x1>, <Register, addr: 0xe0000000f, size: 0x1>, <Register, addr: 0xc0000000e, size: 0x1>, <Register, addr: 0xc0000000d, size: 0x1>, <Register, addr: 0xa0000000b, size: 0x1>, <Register, addr: 0x0, size: 0x1>]"
+
+    assert str(edt.get_node("/reg-nested-ranges/grandparent/parent/node").regs) == \
+        "[<Register, addr: 0x30000000200000001, size: 0x1>]"
+
+def test_pinctrl():
+    '''Test 'pinctrl-<index>'.'''
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+
+    assert str(edt.get_node("/pinctrl/dev").pinctrls) == \
+        "[<PinCtrl, name: zero, configuration nodes: []>, <PinCtrl, name: one, configuration nodes: [<Node /pinctrl/pincontroller/state-1 in 'test.dts', no binding>]>, <PinCtrl, name: two, configuration nodes: [<Node /pinctrl/pincontroller/state-1 in 'test.dts', no binding>, <Node /pinctrl/pincontroller/state-2 in 'test.dts', no binding>]>]"
+
+def test_hierarchy():
+    '''Test Node.parent and Node.children'''
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+
+    assert edt.get_node("/").parent is None
+
+    assert str(edt.get_node("/parent/child-1").parent) == \
+        "<Node /parent in 'test.dts', no binding>"
+
+    assert str(edt.get_node("/parent/child-2/grandchild").parent) == \
+        "<Node /parent/child-2 in 'test.dts', no binding>"
+
+    assert str(edt.get_node("/parent").children) == \
+        "OrderedDict([('child-1', <Node /parent/child-1 in 'test.dts', no binding>), ('child-2', <Node /parent/child-2 in 'test.dts', no binding>)])"
+
+    assert edt.get_node("/parent/child-1").children == {}
+
+def test_include():
+    '''Test 'include:' and the legacy 'inherits: !include ...' in bindings'''
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+
+    assert str(edt.get_node("/binding-include").description) == \
+        "Parent binding"
+
+    assert str(edt.get_node("/binding-include").props) == \
+        "OrderedDict([('foo', <Property, name: foo, type: int, value: 0>), ('bar', <Property, name: bar, type: int, value: 1>), ('baz', <Property, name: baz, type: int, value: 2>), ('qaz', <Property, name: qaz, type: int, value: 3>)])"
+
+def test_include_filters():
+    '''Test property-allowlist and property-blocklist in an include.'''
+
+    fname2path = {'include.yaml': 'test-bindings-include/include.yaml',
+                  'include-2.yaml': 'test-bindings-include/include-2.yaml'}
+
+    with pytest.raises(edtlib.EDTError) as e:
+        with from_here():
+            edtlib.Binding("test-bindings-include/allow-and-blocklist.yaml", fname2path)
+    assert ("should not specify both 'property-allowlist:' and 'property-blocklist:'"
+            in str(e.value))
+
+    with pytest.raises(edtlib.EDTError) as e:
+        with from_here():
+            edtlib.Binding("test-bindings-include/allow-and-blocklist-child.yaml", fname2path)
+    assert ("should not specify both 'property-allowlist:' and 'property-blocklist:'"
+            in str(e.value))
+
+    with pytest.raises(edtlib.EDTError) as e:
+        with from_here():
+            edtlib.Binding("test-bindings-include/allow-not-list.yaml", fname2path)
+    value_str = str(e.value)
+    assert value_str.startswith("'property-allowlist' value")
+    assert value_str.endswith("should be a list")
+
+    with pytest.raises(edtlib.EDTError) as e:
+        with from_here():
+            edtlib.Binding("test-bindings-include/block-not-list.yaml", fname2path)
+    value_str = str(e.value)
+    assert value_str.startswith("'property-blocklist' value")
+    assert value_str.endswith("should be a list")
+
+    with pytest.raises(edtlib.EDTError) as e:
+        with from_here():
+            binding = edtlib.Binding("test-bindings-include/include-invalid-keys.yaml", fname2path)
+    value_str = str(e.value)
+    assert value_str.startswith(
+        "'include:' in test-bindings-include/include-invalid-keys.yaml should not have these "
+        "unexpected contents: ")
+    assert 'bad-key-1' in value_str
+    assert 'bad-key-2' in value_str
+
+    with pytest.raises(edtlib.EDTError) as e:
+        with from_here():
+            binding = edtlib.Binding("test-bindings-include/include-invalid-type.yaml", fname2path)
+    value_str = str(e.value)
+    assert value_str.startswith(
+        "'include:' in test-bindings-include/include-invalid-type.yaml "
+        "should be a string or list, but has type ")
+
+    with pytest.raises(edtlib.EDTError) as e:
+        with from_here():
+            binding = edtlib.Binding("test-bindings-include/include-no-name.yaml", fname2path)
+    value_str = str(e.value)
+    assert value_str.startswith("'include:' element")
+    assert value_str.endswith(
+        "in test-bindings-include/include-no-name.yaml should have a 'name' key")
+
+    with from_here():
+        binding = edtlib.Binding("test-bindings-include/allowlist.yaml", fname2path)
+        assert set(binding.prop2specs.keys()) == {'x'}  # 'x' is allowed
+
+        binding = edtlib.Binding("test-bindings-include/empty-allowlist.yaml", fname2path)
+        assert set(binding.prop2specs.keys()) == set()  # nothing is allowed
+
+        binding = edtlib.Binding("test-bindings-include/blocklist.yaml", fname2path)
+        assert set(binding.prop2specs.keys()) == {'y', 'z'}  # 'x' is blocked
+
+        binding = edtlib.Binding("test-bindings-include/empty-blocklist.yaml", fname2path)
+        assert set(binding.prop2specs.keys()) == {'x', 'y', 'z'}  # nothing is blocked
+
+        binding = edtlib.Binding("test-bindings-include/intermixed.yaml", fname2path)
+        assert set(binding.prop2specs.keys()) == {'x', 'a'}
+
+        binding = edtlib.Binding("test-bindings-include/include-no-list.yaml", fname2path)
+        assert set(binding.prop2specs.keys()) == {'x', 'y', 'z'}
+
+        binding = edtlib.Binding("test-bindings-include/filter-child-bindings.yaml", fname2path)
+        child = binding.child_binding
+        grandchild = child.child_binding
+        assert set(binding.prop2specs.keys()) == {'x'}
+        assert set(child.prop2specs.keys()) == {'child-prop-2'}
+        assert set(grandchild.prop2specs.keys()) == {'grandchild-prop-1'}
+
+
+def test_bus():
+    '''Test 'bus:' and 'on-bus:' in bindings'''
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+
+    assert edt.get_node("/buses/foo-bus").bus == "foo"
+
+    # foo-bus does not itself appear on a bus
+    assert edt.get_node("/buses/foo-bus").on_bus is None
+    assert edt.get_node("/buses/foo-bus").bus_node is None
+
+    # foo-bus/node1 is not a bus node...
+    assert edt.get_node("/buses/foo-bus/node1").bus is None
+    # ...but is on a bus
+    assert edt.get_node("/buses/foo-bus/node1").on_bus == "foo"
+    assert edt.get_node("/buses/foo-bus/node1").bus_node.path == \
+        "/buses/foo-bus"
+
+    # foo-bus/node2 is not a bus node...
+    assert edt.get_node("/buses/foo-bus/node2").bus is None
+    # ...but is on a bus
+    assert edt.get_node("/buses/foo-bus/node2").on_bus == "foo"
+
+    # no-bus-node is not a bus node...
+    assert edt.get_node("/buses/no-bus-node").bus is None
+    # ... and is not on a bus
+    assert edt.get_node("/buses/no-bus-node").on_bus is None
+
+    # Same compatible string, but different bindings from being on different
+    # buses
+    assert str(edt.get_node("/buses/foo-bus/node1").binding_path) == \
+        hpath("test-bindings/device-on-foo-bus.yaml")
+    assert str(edt.get_node("/buses/foo-bus/node2").binding_path) == \
+        hpath("test-bindings/device-on-any-bus.yaml")
+    assert str(edt.get_node("/buses/bar-bus/node").binding_path) == \
+        hpath("test-bindings/device-on-bar-bus.yaml")
+    assert str(edt.get_node("/buses/no-bus-node").binding_path) == \
+        hpath("test-bindings/device-on-any-bus.yaml")
+
+    # foo-bus/node/nested also appears on the foo-bus bus
+    assert edt.get_node("/buses/foo-bus/node1/nested").on_bus == "foo"
+    assert str(edt.get_node("/buses/foo-bus/node1/nested").binding_path) == \
+        hpath("test-bindings/device-on-foo-bus.yaml")
+
+def test_child_binding():
+    '''Test 'child-binding:' in bindings'''
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+    child1 = edt.get_node("/child-binding/child-1")
+    child2 = edt.get_node("/child-binding/child-2")
+    grandchild = edt.get_node("/child-binding/child-1/grandchild")
+
+    assert str(child1.binding_path) == hpath("test-bindings/child-binding.yaml")
+    assert str(child1.description) == "child node"
+    assert str(child1.props) == "OrderedDict([('child-prop', <Property, name: child-prop, type: int, value: 1>)])"
+
+    assert str(child2.binding_path) == hpath("test-bindings/child-binding.yaml")
+    assert str(child2.description) == "child node"
+    assert str(child2.props) == "OrderedDict([('child-prop', <Property, name: child-prop, type: int, value: 3>)])"
+
+    assert str(grandchild.binding_path) == hpath("test-bindings/child-binding.yaml")
+    assert str(grandchild.description) == "grandchild node"
+    assert str(grandchild.props) == "OrderedDict([('grandchild-prop', <Property, name: grandchild-prop, type: int, value: 2>)])"
+
+    with from_here():
+        binding_file = Path("test-bindings/child-binding.yaml").resolve()
+        top = edtlib.Binding(binding_file, {})
+    child = top.child_binding
+    assert Path(top.path) == binding_file
+    assert Path(child.path) == binding_file
+    assert top.compatible == 'top-binding'
+    assert child.compatible is None
+
+    with from_here():
+        binding_file = Path("test-bindings/child-binding-with-compat.yaml").resolve()
+        top = edtlib.Binding(binding_file, {})
+    child = top.child_binding
+    assert Path(top.path) == binding_file
+    assert Path(child.path) == binding_file
+    assert top.compatible == 'top-binding-with-compat'
+    assert child.compatible == 'child-compat'
+
+def test_props():
+    '''Test Node.props (derived from DT and 'properties:' in the binding)'''
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+    filenames = {i: hpath(f'test-bindings/phandle-array-controller-{i}.yaml')
+                 for i in range(0, 4)}
+
+    assert str(edt.get_node("/props").props["int"]) == \
+        "<Property, name: int, type: int, value: 1>"
+
+    assert str(edt.get_node("/props").props["existent-boolean"]) == \
+        "<Property, name: existent-boolean, type: boolean, value: True>"
+
+    assert str(edt.get_node("/props").props["nonexistent-boolean"]) == \
+        "<Property, name: nonexistent-boolean, type: boolean, value: False>"
+
+    assert str(edt.get_node("/props").props["array"]) == \
+        "<Property, name: array, type: array, value: [1, 2, 3]>"
+
+    assert str(edt.get_node("/props").props["uint8-array"]) == \
+        r"<Property, name: uint8-array, type: uint8-array, value: b'\x124'>"
+
+    assert str(edt.get_node("/props").props["string"]) == \
+        "<Property, name: string, type: string, value: 'foo'>"
+
+    assert str(edt.get_node("/props").props["string-array"]) == \
+        "<Property, name: string-array, type: string-array, value: ['foo', 'bar', 'baz']>"
+
+    assert str(edt.get_node("/props").props["phandle-ref"]) == \
+        f"<Property, name: phandle-ref, type: phandle, value: <Node /ctrl-1 in 'test.dts', binding {filenames[1]}>>"
+
+    assert str(edt.get_node("/props").props["phandle-refs"]) == \
+        f"<Property, name: phandle-refs, type: phandles, value: [<Node /ctrl-1 in 'test.dts', binding {filenames[1]}>, <Node /ctrl-2 in 'test.dts', binding {filenames[2]}>]>"
+
+    assert str(edt.get_node("/props").props["phandle-array-foos"]) == \
+        f"<Property, name: phandle-array-foos, type: phandle-array, value: [<ControllerAndData, controller: <Node /ctrl-1 in 'test.dts', binding {filenames[1]}>, data: OrderedDict([('one', 1)])>, <ControllerAndData, controller: <Node /ctrl-2 in 'test.dts', binding {filenames[2]}>, data: OrderedDict([('one', 2), ('two', 3)])>]>"
+
+    assert str(edt.get_node("/props-2").props["phandle-array-foos"]) == \
+        ("<Property, name: phandle-array-foos, type: phandle-array, value: ["
+         f"<ControllerAndData, name: a, controller: <Node /ctrl-0-1 in 'test.dts', binding {filenames[0]}>, data: OrderedDict()>, "
+         "None, "
+         f"<ControllerAndData, name: b, controller: <Node /ctrl-0-2 in 'test.dts', binding {filenames[0]}>, data: OrderedDict()>]>")
+
+    assert str(edt.get_node("/props").props["foo-gpios"]) == \
+        f"<Property, name: foo-gpios, type: phandle-array, value: [<ControllerAndData, controller: <Node /ctrl-1 in 'test.dts', binding {filenames[1]}>, data: OrderedDict([('gpio-one', 1)])>]>"
+
+    assert str(edt.get_node("/props").props["path"]) == \
+        f"<Property, name: path, type: path, value: <Node /ctrl-1 in 'test.dts', binding {filenames[1]}>>"
+
+def test_nexus():
+    '''Test <prefix>-map via gpio-map (the most common case).'''
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+    filename = hpath('test-bindings/gpio-dst.yaml')
+
+    assert str(edt.get_node("/gpio-map/source").props["foo-gpios"]) == \
+        f"<Property, name: foo-gpios, type: phandle-array, value: [<ControllerAndData, controller: <Node /gpio-map/destination in 'test.dts', binding {filename}>, data: OrderedDict([('val', 6)])>, <ControllerAndData, controller: <Node /gpio-map/destination in 'test.dts', binding {filename}>, data: OrderedDict([('val', 5)])>]>"
+
+def test_prop_defaults():
+    '''Test property default values given in bindings'''
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+
+    assert str(edt.get_node("/defaults").props) == \
+        r"OrderedDict([('int', <Property, name: int, type: int, value: 123>), ('array', <Property, name: array, type: array, value: [1, 2, 3]>), ('uint8-array', <Property, name: uint8-array, type: uint8-array, value: b'\x89\xab\xcd'>), ('string', <Property, name: string, type: string, value: 'hello'>), ('string-array', <Property, name: string-array, type: string-array, value: ['hello', 'there']>), ('default-not-used', <Property, name: default-not-used, type: int, value: 234>)])"
+
+def test_prop_enums():
+    '''test properties with enum: in the binding'''
+
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"])
+    props = edt.get_node('/enums').props
+    int_enum = props['int-enum']
+    string_enum = props['string-enum']
+    tokenizable_enum = props['tokenizable-enum']
+    tokenizable_lower_enum = props['tokenizable-lower-enum']
+    no_enum = props['no-enum']
+
+    assert int_enum.val == 1
+    assert int_enum.enum_index == 0
+    assert not int_enum.spec.enum_tokenizable
+    assert not int_enum.spec.enum_upper_tokenizable
+
+    assert string_enum.val == 'foo_bar'
+    assert string_enum.enum_index == 1
+    assert not string_enum.spec.enum_tokenizable
+    assert not string_enum.spec.enum_upper_tokenizable
+
+    assert tokenizable_enum.val == '123 is ok'
+    assert tokenizable_enum.val_as_token == '123_is_ok'
+    assert tokenizable_enum.enum_index == 2
+    assert tokenizable_enum.spec.enum_tokenizable
+    assert tokenizable_enum.spec.enum_upper_tokenizable
+
+    assert tokenizable_lower_enum.val == 'bar'
+    assert tokenizable_lower_enum.val_as_token == 'bar'
+    assert tokenizable_lower_enum.enum_index == 0
+    assert tokenizable_lower_enum.spec.enum_tokenizable
+    assert not tokenizable_lower_enum.spec.enum_upper_tokenizable
+
+    assert no_enum.enum_index is None
+    assert not no_enum.spec.enum_tokenizable
+    assert not no_enum.spec.enum_upper_tokenizable
+
+def test_binding_inference():
+    '''Test inferred bindings for special zephyr-specific nodes.'''
+    warnings = io.StringIO()
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"], warnings)
+
+    assert str(edt.get_node("/zephyr,user").props) == r"OrderedDict()"
+
+    with from_here():
+        edt = edtlib.EDT("test.dts", ["test-bindings"], warnings,
+                         infer_binding_for_paths=["/zephyr,user"])
+    filenames = {i: hpath(f'test-bindings/phandle-array-controller-{i}.yaml')
+                 for i in range(1, 3)}
+
+    assert str(edt.get_node("/zephyr,user").props) == \
+        rf"OrderedDict([('boolean', <Property, name: boolean, type: boolean, value: True>), ('bytes', <Property, name: bytes, type: uint8-array, value: b'\x81\x82\x83'>), ('number', <Property, name: number, type: int, value: 23>), ('numbers', <Property, name: numbers, type: array, value: [1, 2, 3]>), ('string', <Property, name: string, type: string, value: 'text'>), ('strings', <Property, name: strings, type: string-array, value: ['a', 'b', 'c']>), ('handle', <Property, name: handle, type: phandle, value: <Node /ctrl-1 in 'test.dts', binding {filenames[1]}>>), ('phandles', <Property, name: phandles, type: phandles, value: [<Node /ctrl-1 in 'test.dts', binding {filenames[1]}>, <Node /ctrl-2 in 'test.dts', binding {filenames[2]}>]>), ('phandle-array-foos', <Property, name: phandle-array-foos, type: phandle-array, value: [<ControllerAndData, controller: <Node /ctrl-2 in 'test.dts', binding {filenames[2]}>, data: OrderedDict([('one', 1), ('two', 2)])>]>)])"
+
+def test_multi_bindings():
+    '''Test having multiple directories with bindings'''
+    with from_here():
+        edt = edtlib.EDT("test-multidir.dts", ["test-bindings", "test-bindings-2"])
+
+    assert str(edt.get_node("/in-dir-1").binding_path) == \
+        hpath("test-bindings/multidir.yaml")
+
+    assert str(edt.get_node("/in-dir-2").binding_path) == \
+        hpath("test-bindings-2/multidir.yaml")
+
+def test_dependencies():
+    ''''Test dependency relations'''
+    with from_here():
+        edt = edtlib.EDT("test-multidir.dts", ["test-bindings", "test-bindings-2"])
+
+    assert edt.get_node("/").dep_ordinal == 0
+    assert edt.get_node("/in-dir-1").dep_ordinal == 1
+    assert edt.get_node("/") in edt.get_node("/in-dir-1").depends_on
+    assert edt.get_node("/in-dir-1") in edt.get_node("/").required_by
+
+def test_slice_errs(tmp_path):
+    '''Test error messages from the internal _slice() helper'''
+
+    dts_file = tmp_path / "error.dts"
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	#address-cells = <1>;
+	#size-cells = <2>;
+
+	sub {
+		reg = <3>;
+	};
+};
+""",
+                 dts_file,
+                 f"'reg' property in <Node /sub in '{dts_file}'> has length 4, which is not evenly divisible by 12 (= 4*(<#address-cells> (= 1) + <#size-cells> (= 2))). Note that #*-cells properties come either from the parent node or from the controller (in the case of 'interrupts').")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	sub {
+		interrupts = <1>;
+		interrupt-parent = < &{/controller} >;
+	};
+	controller {
+		interrupt-controller;
+		#interrupt-cells = <2>;
+	};
+};
+""",
+                 dts_file,
+                 f"'interrupts' property in <Node /sub in '{dts_file}'> has length 4, which is not evenly divisible by 8 (= 4*<#interrupt-cells>). Note that #*-cells properties come either from the parent node or from the controller (in the case of 'interrupts').")
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	#address-cells = <1>;
+
+	sub-1 {
+		#address-cells = <2>;
+		#size-cells = <3>;
+		ranges = <4 5>;
+
+		sub-2 {
+			reg = <1 2 3 4 5>;
+		};
+	};
+};
+""",
+                 dts_file,
+                 f"'ranges' property in <Node /sub-1 in '{dts_file}'> has length 8, which is not evenly divisible by 24 (= 4*(<#address-cells> (= 2) + <#address-cells for parent> (= 1) + <#size-cells> (= 3))). Note that #*-cells properties come either from the parent node or from the controller (in the case of 'interrupts').")
+
+def test_bad_compatible(tmp_path):
+    # An invalid compatible should cause an error, even on a node with
+    # no binding.
+
+    dts_file = tmp_path / "error.dts"
+
+    verify_error("""
+/dts-v1/;
+
+/ {
+	foo {
+		compatible = "no, whitespace";
+	};
+};
+""",
+                 dts_file,
+                 r"node '/foo' compatible 'no, whitespace' must match this regular expression: '^[a-zA-Z][a-zA-Z0-9,+\-._]+$'")
+
+def verify_error(dts, dts_file, expected_err):
+    # Verifies that parsing a file 'dts_file' with the contents 'dts'
+    # (a string) raises an EDTError with the message 'expected_err'.
+    #
+    # The path 'dts_file' is written with the string 'dts' before the
+    # test is run.
+
+    with open(dts_file, "w", encoding="utf-8") as f:
+        f.write(dts)
+        f.flush()  # Can't have unbuffered text IO, so flush() instead
+
+    with pytest.raises(edtlib.EDTError) as e:
+        edtlib.EDT(dts_file, [])
+
+    assert str(e.value) == expected_err
diff --git a/tools/dts/python-devicetree/tox.ini b/tools/dts/python-devicetree/tox.ini
new file mode 100644
index 0000000000000000000000000000000000000000..54b08ec094975f603767352090fd28095a52284a
--- /dev/null
+++ b/tools/dts/python-devicetree/tox.ini
@@ -0,0 +1,19 @@
+[tox]
+envlist=py3
+
+[testenv]
+deps =
+    setuptools-scm
+    pytest
+    types-PyYAML
+    mypy
+setenv =
+    TOXTEMPDIR={envtmpdir}
+commands =
+  python -m pytest {posargs:tests}
+  python -m mypy --config-file={toxinidir}/tox.ini --package=devicetree
+
+[mypy]
+mypy_path=src
+ignore_missing_imports=True
+