diff --git a/cmake/modules/dts.cmake b/cmake/modules/dts.cmake
index 49408730dcd..c6e01aff252 100644
--- a/cmake/modules/dts.cmake
+++ b/cmake/modules/dts.cmake
@@ -122,14 +122,6 @@ set(GEN_DRIVER_KCONFIG_SCRIPT   ${DT_SCRIPTS}/gen_driver_kconfig_dts.py)
 # Generated Kconfig symbols go here.
 set(DTS_KCONFIG                 ${KCONFIG_BINARY_DIR}/Kconfig.dts)
 
-# This generates DT information needed by the CMake APIs.
-set(GEN_DTS_CMAKE_SCRIPT        ${DT_SCRIPTS}/gen_dts_cmake.py)
-# The generated information itself, which we include() after
-# creating it.
-set(DTS_CMAKE                   ${PROJECT_BINARY_DIR}/dts.cmake)
-# The CMake target to be initialized by including ${DTS_CMAKE}.
-set(DEVICETREE_TARGET           devicetree_target)
-
 # The location of a file containing known vendor prefixes, relative to
 # each element of DTS_ROOT. Users can define their own in their own
 # modules.
@@ -285,7 +277,6 @@ set_property(DIRECTORY APPEND PROPERTY
   ${GEN_EDT_SCRIPT}
   ${GEN_DEFINES_SCRIPT}
   ${GEN_DRIVER_KCONFIG_SCRIPT}
-  ${GEN_DTS_CMAKE_SCRIPT}
   )
 
 #
@@ -348,31 +339,12 @@ if(NOT "${ret}" STREQUAL "0")
 endif()
 
 #
-# Run GEN_DTS_CMAKE_SCRIPT.
-#
-# A temporary file is copied to the original file if it differs. This prevents issue such as a
-# cycle when sysbuild is used of configuring and building multiple times due to the dts.cmake file
-# of images having a newer modification time than the sysbuild build.ninja file, despite the
-# output having not changed
+# Import devicetree contents into CMake.
+# This enables the CMake dt_* API.
 #
-set(dts_cmake_tmp ${DTS_CMAKE}.new)
 
-execute_process(
-  COMMAND ${PYTHON_EXECUTABLE} ${GEN_DTS_CMAKE_SCRIPT}
-  --edt-pickle ${EDT_PICKLE}
-  --cmake-out ${dts_cmake_tmp}
-  WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
-  RESULT_VARIABLE ret
-  )
-if(NOT "${ret}" STREQUAL "0")
-  message(FATAL_ERROR "gen_dts_cmake.py failed with return code: ${ret}")
-else()
-  zephyr_file_copy(${dts_cmake_tmp} ${DTS_CMAKE} ONLY_IF_DIFFERENT)
-  file(REMOVE ${dts_cmake_tmp})
-  set(dts_cmake_tmp)
-  message(STATUS "Including generated dts.cmake file: ${DTS_CMAKE}")
-  include(${DTS_CMAKE})
-endif()
+add_custom_target(devicetree_target)
+zephyr_dt_import(EDT_PICKLE_FILE ${EDT_PICKLE} TARGET devicetree_target)
 
 #
 # Run dtc if it was found.
diff --git a/cmake/modules/extensions.cmake b/cmake/modules/extensions.cmake
index 4d09c7eda3e..c3841283334 100644
--- a/cmake/modules/extensions.cmake
+++ b/cmake/modules/extensions.cmake
@@ -3817,11 +3817,12 @@ endfunction()
 #   path to the aliased node in these functions. The usage comments
 #   will make this clear in each case.
 #
-# - Each of these methods also has a sysbuild_dt_* counterpart.
-#   See share/sysbuild/cmake/modules/sysbuild_extensions.cmake.
+# - These methods are also available to sysbuild. To retrieve the DT
+#   information of some <image>, after its CMake configuration step,
+#   the dt_* function call must include a "TARGET <image>" argument.
 
 # Usage:
-#   dt_nodelabel(<var> NODELABEL <label>)
+#   dt_nodelabel(<var> NODELABEL <label> [REQUIRED] [TARGET <target>])
 #
 # Function for retrieving the node path for the node having nodelabel
 # <label>.
@@ -3845,14 +3846,14 @@ endfunction()
 # <var>              : Return variable where the node path will be stored
 # NODELABEL <label>  : Node label
 # REQUIRED           : Generate a fatal error if the node-label is not found
+# TARGET <target>    : Optional target to retrieve devicetree information from
 function(dt_nodelabel var)
-  if(NOT DEFINED DEVICETREE_TARGET OR NOT TARGET "${DEVICETREE_TARGET}")
-    message(FATAL_ERROR "dt_nodelabel(${ARGV0} ...) devicetree is not available.")
-  endif()
-
   set(options "REQUIRED")
   set(req_single_args "NODELABEL")
-  cmake_parse_arguments(DT_LABEL "${options}" "${req_single_args}" "" ${ARGN})
+  set(single_args "TARGET")
+  cmake_parse_arguments(DT_LABEL "${options}" "${req_single_args};${single_args}" "" ${ARGN})
+
+  dt_target_internal(DT_LABEL_TARGET)
 
   if(${ARGV0} IN_LIST req_single_args)
     message(FATAL_ERROR "dt_nodelabel(${ARGV0} ...) missing return parameter.")
@@ -3866,7 +3867,7 @@ function(dt_nodelabel var)
     endif()
   endforeach()
 
-  get_target_property(${var} "${DEVICETREE_TARGET}" "DT_NODELABEL|${DT_LABEL_NODELABEL}")
+  get_target_property(${var} ${DT_LABEL_TARGET} "DT_NODELABEL|${DT_LABEL_NODELABEL}")
   if(${${var}} STREQUAL ${var}-NOTFOUND)
     if(DT_LABEL_REQUIRED)
       message(FATAL_ERROR "required nodelabel not found: ${DT_LABEL_NODELABEL}")
@@ -3878,7 +3879,7 @@ function(dt_nodelabel var)
 endfunction()
 
 # Usage:
-#   dt_alias(<var> PROPERTY <prop>)
+#   dt_alias(<var> PROPERTY <prop> [REQUIRED] [TARGET <target>])
 #
 # Get a node path for an /aliases node property.
 #
@@ -3897,14 +3898,14 @@ endfunction()
 # <var>           : Return variable where the node path will be stored
 # PROPERTY <prop> : The alias to check
 # REQUIRED        : Generate a fatal error if the alias is not found
+# TARGET <target> : Optional target to retrieve devicetree information from
 function(dt_alias var)
-  if(NOT DEFINED DEVICETREE_TARGET OR NOT TARGET "${DEVICETREE_TARGET}")
-    message(FATAL_ERROR "dt_alias(${ARGV0} ...) devicetree is not available.")
-  endif()
-
   set(options "REQUIRED")
   set(req_single_args "PROPERTY")
-  cmake_parse_arguments(DT_ALIAS "${options}" "${req_single_args}" "" ${ARGN})
+  set(single_args "TARGET")
+  cmake_parse_arguments(DT_ALIAS "${options}" "${req_single_args};${single_args}" "" ${ARGN})
+
+  dt_target_internal(DT_ALIAS_TARGET)
 
   if(${ARGV0} IN_LIST req_single_args)
     message(FATAL_ERROR "dt_alias(${ARGV0} ...) missing return parameter.")
@@ -3918,7 +3919,7 @@ function(dt_alias var)
     endif()
   endforeach()
 
-  get_target_property(${var} "${DEVICETREE_TARGET}" "DT_ALIAS|${DT_ALIAS_PROPERTY}")
+  get_target_property(${var} ${DT_ALIAS_TARGET} "DT_ALIAS|${DT_ALIAS_PROPERTY}")
   if(${${var}} STREQUAL ${var}-NOTFOUND)
     if(DT_ALIAS_REQUIRED)
       message(FATAL_ERROR "required alias not found: ${DT_ALIAS_PROPERTY}")
@@ -3930,7 +3931,7 @@ function(dt_alias var)
 endfunction()
 
 # Usage:
-#   dt_node_exists(<var> PATH <path>)
+#   dt_node_exists(<var> PATH <path> [TARGET <target>])
 #
 # Tests whether a node with path <path> exists in the devicetree.
 #
@@ -3943,15 +3944,15 @@ endfunction()
 # The result of the check, either TRUE or FALSE, will be returned in
 # the <var> parameter.
 #
-# <var>       : Return variable where the check result will be returned
-# PATH <path> : Node path
+# <var>           : Return variable where the check result will be returned
+# PATH <path>     : Node path
+# TARGET <target> : Optional target to retrieve devicetree information from
 function(dt_node_exists var)
-  if(NOT DEFINED DEVICETREE_TARGET OR NOT TARGET "${DEVICETREE_TARGET}")
-    message(FATAL_ERROR "dt_node_exists(${ARGV0} ...) devicetree is not available.")
-  endif()
-
   set(req_single_args "PATH")
-  cmake_parse_arguments(DT_NODE "" "${req_single_args}" "" ${ARGN})
+  set(single_args "TARGET")
+  cmake_parse_arguments(DT_NODE "" "${req_single_args};${single_args}" "" ${ARGN})
+
+  dt_target_internal(DT_NODE_TARGET)
 
   if(${ARGV0} IN_LIST req_single_args)
     message(FATAL_ERROR "dt_node_exists(${ARGV0} ...) missing return parameter.")
@@ -3965,7 +3966,7 @@ function(dt_node_exists var)
     endif()
   endforeach()
 
-  dt_path_internal(canonical "${DT_NODE_PATH}")
+  dt_path_internal(canonical "${DT_NODE_PATH}" "${DT_NODE_TARGET}")
   if (DEFINED canonical)
     set(${var} TRUE PARENT_SCOPE)
   else()
@@ -3974,7 +3975,7 @@ function(dt_node_exists var)
 endfunction()
 
 # Usage:
-#   dt_node_has_status(<var> PATH <path> STATUS <status>)
+#   dt_node_has_status(<var> PATH <path> STATUS <status> [TARGET <target>])
 #
 # Tests whether <path> refers to a node which:
 # - exists in the devicetree, and
@@ -3994,13 +3995,13 @@ endfunction()
 # <var>           : Return variable where the check result will be returned
 # PATH <path>     : Node path
 # STATUS <status> : Status to check
+# TARGET <target> : Optional target to retrieve devicetree information from
 function(dt_node_has_status var)
-  if(NOT DEFINED DEVICETREE_TARGET OR NOT TARGET "${DEVICETREE_TARGET}")
-    message(FATAL_ERROR "dt_node_has_status(${ARGV0} ...) devicetree is not available.")
-  endif()
-
   set(req_single_args "PATH;STATUS")
-  cmake_parse_arguments(DT_NODE "" "${req_single_args}" "" ${ARGN})
+  set(single_args "TARGET")
+  cmake_parse_arguments(DT_NODE "" "${req_single_args};${single_args}" "" ${ARGN})
+
+  dt_target_internal(DT_NODE_TARGET)
 
   if(${ARGV0} IN_LIST req_single_args)
     message(FATAL_ERROR "dt_node_has_status(${ARGV0} ...) missing return parameter.")
@@ -4014,13 +4015,13 @@ function(dt_node_has_status var)
     endif()
   endforeach()
 
-  dt_path_internal(canonical ${DT_NODE_PATH})
+  dt_path_internal(canonical ${DT_NODE_PATH} ${DT_NODE_TARGET})
   if(NOT DEFINED canonical)
     set(${var} FALSE PARENT_SCOPE)
     return()
   endif()
 
-  dt_prop(status PATH ${canonical} PROPERTY status)
+  dt_prop(status PATH ${canonical} PROPERTY status TARGET ${DT_NODE_TARGET})
 
   if(NOT DEFINED status OR status STREQUAL "ok")
     set(status "okay")
@@ -4035,7 +4036,7 @@ endfunction()
 
 # Usage:
 #
-#   dt_prop(<var> PATH <path> PROPERTY <prop> [INDEX <idx>])
+#   dt_prop(<var> PATH <path> PROPERTY <prop> [INDEX <idx>] [REQUIRED] [TARGET <target>])
 #
 # Get a devicetree property value. The value will be returned in the
 # <var> parameter.
@@ -4084,16 +4085,15 @@ endfunction()
 #                  appears in the DTS source
 # INDEX <idx>    : Optional index when retrieving a value in an array property
 # REQUIRED       : Generate a fatal error if the property is not found
+# TARGET <target>: Optional target to retrieve devicetree information from
 function(dt_prop var)
-  if(NOT DEFINED DEVICETREE_TARGET OR NOT TARGET "${DEVICETREE_TARGET}")
-    message(FATAL_ERROR "dt_prop(${ARGV0} ...) devicetree is not available.")
-  endif()
-
   set(options "REQUIRED")
   set(req_single_args "PATH;PROPERTY")
-  set(single_args "INDEX")
+  set(single_args "INDEX;TARGET")
   cmake_parse_arguments(DT_PROP "${options}" "${req_single_args};${single_args}" "" ${ARGN})
 
+  dt_target_internal(DT_PROP_TARGET)
+
   if(${ARGV0} IN_LIST req_single_args)
     message(FATAL_ERROR "dt_prop(${ARGV0} ...) missing return parameter.")
   endif()
@@ -4106,8 +4106,8 @@ function(dt_prop var)
     endif()
   endforeach()
 
-  dt_path_internal(canonical "${DT_PROP_PATH}")
-  get_property(exists TARGET "${DEVICETREE_TARGET}"
+  dt_path_internal(canonical "${DT_PROP_PATH}" "${DT_PROP_TARGET}")
+  get_property(exists TARGET ${DT_PROP_TARGET}
       PROPERTY "DT_PROP|${canonical}|${DT_PROP_PROPERTY}"
       SET
   )
@@ -4120,7 +4120,7 @@ function(dt_prop var)
     return()
   endif()
 
-  get_target_property(val "${DEVICETREE_TARGET}"
+  get_target_property(val ${DT_PROP_TARGET}
       "DT_PROP|${canonical}|${DT_PROP_PROPERTY}"
   )
 
@@ -4134,7 +4134,7 @@ endfunction()
 
 # Usage:
 #
-#   dt_comp_path(<var> COMPATIBLE <compatible> [INDEX <idx>])
+#   dt_comp_path(<var> COMPATIBLE <compatible> [INDEX <idx>] [TARGET <target>])
 #
 # Get a list of paths for the nodes with the given compatible. The value will
 # be returned in the <var> parameter.
@@ -4147,16 +4147,15 @@ endfunction()
 # COMPATIBLE <compatible>: Compatible for which the list of paths should be
 #                          returned, as it appears in the DTS source
 # INDEX <idx>            : Optional index when retrieving a value in an array property
+# TARGET <target>        : Optional target to retrieve devicetree information from
 
 function(dt_comp_path var)
-  if(NOT DEFINED DEVICETREE_TARGET OR NOT TARGET "${DEVICETREE_TARGET}")
-    message(FATAL_ERROR "dt_comp_path(${ARGV0} ...) devicetree is not available.")
-  endif()
-
   set(req_single_args "COMPATIBLE")
-  set(single_args "INDEX")
+  set(single_args "INDEX;TARGET")
   cmake_parse_arguments(DT_COMP "" "${req_single_args};${single_args}" "" ${ARGN})
 
+  dt_target_internal(DT_COMP_TARGET)
+
   if(${ARGV0} IN_LIST req_single_args)
     message(FATAL_ERROR "dt_comp_path(${ARGV0} ...) missing return parameter.")
   endif()
@@ -4169,7 +4168,7 @@ function(dt_comp_path var)
     endif()
   endforeach()
 
-  get_property(exists TARGET "${DEVICETREE_TARGET}"
+  get_property(exists TARGET ${DT_COMP_TARGET}
       PROPERTY "DT_COMP|${DT_COMP_COMPATIBLE}"
       SET
   )
@@ -4179,7 +4178,7 @@ function(dt_comp_path var)
     return()
   endif()
 
-  get_target_property(val "${DEVICETREE_TARGET}"
+  get_target_property(val ${DT_COMP_TARGET}
       "DT_COMP|${DT_COMP_COMPATIBLE}"
   )
 
@@ -4192,7 +4191,7 @@ function(dt_comp_path var)
 endfunction()
 
 # Usage:
-#   dt_num_regs(<var> PATH <path>)
+#   dt_num_regs(<var> PATH <path> [TARGET <target>])
 #
 # Get the number of register blocks in the node's reg property;
 # this may be zero.
@@ -4207,13 +4206,13 @@ endfunction()
 #
 # <var>          : Return variable where the property value will be stored
 # PATH <path>    : Node path
+# TARGET <target>: Optional target to retrieve devicetree information from
 function(dt_num_regs var)
-  if(NOT DEFINED DEVICETREE_TARGET OR NOT TARGET "${DEVICETREE_TARGET}")
-    message(FATAL_ERROR "dt_num_regs(${ARGV0} ...) devicetree is not available.")
-  endif()
-
   set(req_single_args "PATH")
-  cmake_parse_arguments(DT_REG "" "${req_single_args}" "" ${ARGN})
+  set(single_args "TARGET")
+  cmake_parse_arguments(DT_REG "" "${req_single_args};${single_args}" "" ${ARGN})
+
+  dt_target_internal(DT_REG_TARGET)
 
   if(${ARGV0} IN_LIST req_single_args)
     message(FATAL_ERROR "dt_num_regs(${ARGV0} ...) missing return parameter.")
@@ -4227,14 +4226,14 @@ function(dt_num_regs var)
     endif()
   endforeach()
 
-  dt_path_internal(canonical "${DT_REG_PATH}")
-  get_target_property(${var} "${DEVICETREE_TARGET}" "DT_REG|${canonical}|NUM")
+  dt_path_internal(canonical "${DT_REG_PATH}" "${DT_REG_TARGET}")
+  get_target_property(${var} ${DT_REG_TARGET} "DT_REG|${canonical}|NUM")
 
   set(${var} ${${var}} PARENT_SCOPE)
 endfunction()
 
 # Usage:
-#   dt_reg_addr(<var> PATH <path> [INDEX <idx>] [NAME <name>])
+#   dt_reg_addr(<var> PATH <path> [INDEX <idx>] [NAME <name>] [TARGET <target>])
 #
 # Get the base address of the register block at index <idx>, or with
 # name <name>. If <idx> and <name> are both omitted, the value at
@@ -4257,15 +4256,14 @@ endfunction()
 # PATH <path>    : Node path
 # INDEX <idx>    : Register block index number
 # NAME <name>    : Register block name
+# TARGET <target>: Optional target to retrieve devicetree information from
 function(dt_reg_addr var)
-  if(NOT DEFINED DEVICETREE_TARGET OR NOT TARGET "${DEVICETREE_TARGET}")
-    message(FATAL_ERROR "dt_reg_addr(${ARGV0} ...) devicetree is not available.")
-  endif()
-
   set(req_single_args "PATH")
-  set(single_args "INDEX;NAME")
+  set(single_args "INDEX;NAME;TARGET")
   cmake_parse_arguments(DT_REG "" "${req_single_args};${single_args}" "" ${ARGN})
 
+  dt_target_internal(DT_REG_TARGET)
+
   if(${ARGV0} IN_LIST req_single_args)
     message(FATAL_ERROR "dt_reg_addr(${ARGV0} ...) missing return parameter.")
   endif()
@@ -4283,15 +4281,16 @@ function(dt_reg_addr var)
   elseif(NOT DEFINED DT_REG_INDEX AND NOT DEFINED DT_REG_NAME)
     set(DT_REG_INDEX 0)
   elseif(DEFINED DT_REG_NAME)
-    dt_reg_index_private(DT_REG_INDEX "${DT_REG_PATH}" "${DT_REG_NAME}")
+    dt_prop(reg_names PATH "${DT_REG_PATH}" PROPERTY "reg-names" TARGET "${DT_REG_TARGET}")
+    list(FIND reg_names "${DT_REG_NAME}" DT_REG_INDEX)
     if(DT_REG_INDEX EQUAL "-1")
       set(${var} PARENT_SCOPE)
       return()
     endif()
   endif()
 
-  dt_path_internal(canonical "${DT_REG_PATH}")
-  get_target_property(${var}_list "${DEVICETREE_TARGET}" "DT_REG|${canonical}|ADDR")
+  dt_path_internal(canonical "${DT_REG_PATH}" "${DT_REG_TARGET}")
+  get_target_property(${var}_list ${DT_REG_TARGET} "DT_REG|${canonical}|ADDR")
 
   list(GET ${var}_list ${DT_REG_INDEX} ${var})
 
@@ -4303,7 +4302,7 @@ function(dt_reg_addr var)
 endfunction()
 
 # Usage:
-#   dt_reg_size(<var> PATH <path> [INDEX <idx>] [NAME <name>])
+#   dt_reg_size(<var> PATH <path> [INDEX <idx>] [NAME <name>] [TARGET <target>])
 #
 # Get the size of the register block at index <idx>, or with
 # name <name>. If <idx> and <name> are both omitted, the value at
@@ -4321,15 +4320,14 @@ endfunction()
 # PATH <path>    : Node path
 # INDEX <idx>    : Register block index number
 # NAME <name>    : Register block name
+# TARGET <target>: Optional target to retrieve devicetree information from
 function(dt_reg_size var)
-  if(NOT DEFINED DEVICETREE_TARGET OR NOT TARGET "${DEVICETREE_TARGET}")
-    message(FATAL_ERROR "dt_reg_size(${ARGV0} ...) devicetree is not available.")
-  endif()
-
   set(req_single_args "PATH")
-  set(single_args "INDEX;NAME")
+  set(single_args "INDEX;NAME;TARGET")
   cmake_parse_arguments(DT_REG "" "${req_single_args};${single_args}" "" ${ARGN})
 
+  dt_target_internal(DT_REG_TARGET)
+
   if(${ARGV0} IN_LIST req_single_args)
     message(FATAL_ERROR "dt_reg_size(${ARGV0} ...) missing return parameter.")
   endif()
@@ -4347,15 +4345,16 @@ function(dt_reg_size var)
   elseif(NOT DEFINED DT_REG_INDEX AND NOT DEFINED DT_REG_NAME)
     set(DT_REG_INDEX 0)
   elseif(DEFINED DT_REG_NAME)
-    dt_reg_index_private(DT_REG_INDEX "${DT_REG_PATH}" "${DT_REG_NAME}")
+    dt_prop(reg_names PATH "${DT_REG_PATH}" PROPERTY "reg-names" TARGET "${DT_REG_TARGET}")
+    list(FIND reg_names "${DT_REG_NAME}" DT_REG_INDEX)
     if(DT_REG_INDEX EQUAL "-1")
       set(${var} PARENT_SCOPE)
       return()
     endif()
   endif()
 
-  dt_path_internal(canonical "${DT_REG_PATH}")
-  get_target_property(${var}_list "${DEVICETREE_TARGET}" "DT_REG|${canonical}|SIZE")
+  dt_path_internal(canonical "${DT_REG_PATH}" "${DT_REG_TARGET}")
+  get_target_property(${var}_list ${DT_REG_TARGET} "DT_REG|${canonical}|SIZE")
 
   list(GET ${var}_list ${DT_REG_INDEX} ${var})
 
@@ -4366,19 +4365,8 @@ function(dt_reg_size var)
   set(${var} ${${var}} PARENT_SCOPE)
 endfunction()
 
-# Internal helper for dt_reg_addr/dt_reg_size; not meant to be used directly
-function(dt_reg_index_private var path name)
-  dt_prop(reg_names PATH "${path}" PROPERTY "reg-names")
-  if(NOT DEFINED reg_names)
-    set(index "-1")
-  else()
-    list(FIND reg_names "${name}" index)
-  endif()
-  set(${var} "${index}" PARENT_SCOPE)
-endfunction()
-
 # Usage:
-#   dt_has_chosen(<var> PROPERTY <prop>)
+#   dt_has_chosen(<var> PROPERTY <prop> [TARGET <target>])
 #
 # Test if the devicetree's /chosen node has a given property
 # <prop> which contains the path to a node.
@@ -4402,13 +4390,13 @@ endfunction()
 #
 # <var>           : Return variable
 # PROPERTY <prop> : Chosen property
+# TARGET <target> : Optional target to retrieve devicetree information from
 function(dt_has_chosen var)
-  if(NOT DEFINED DEVICETREE_TARGET OR NOT TARGET "${DEVICETREE_TARGET}")
-    message(FATAL_ERROR "dt_has_chosen(${ARGV0} ...) devicetree is not available.")
-  endif()
-
   set(req_single_args "PROPERTY")
-  cmake_parse_arguments(DT_CHOSEN "" "${req_single_args}" "" ${ARGN})
+  set(single_args "TARGET")
+  cmake_parse_arguments(DT_CHOSEN "" "${req_single_args};${single_args}" "" ${ARGN})
+
+  dt_target_internal(DT_CHOSEN_TARGET)
 
   if(${ARGV0} IN_LIST req_single_args)
     message(FATAL_ERROR "dt_has_chosen(${ARGV0} ...) missing return parameter.")
@@ -4422,7 +4410,7 @@ function(dt_has_chosen var)
     endif()
   endforeach()
 
-  get_target_property(exists "${DEVICETREE_TARGET}" "DT_CHOSEN|${DT_CHOSEN_PROPERTY}")
+  get_target_property(exists ${DT_CHOSEN_TARGET} "DT_CHOSEN|${DT_CHOSEN_PROPERTY}")
 
   if(${exists} STREQUAL exists-NOTFOUND)
     set(${var} FALSE PARENT_SCOPE)
@@ -4432,7 +4420,7 @@ function(dt_has_chosen var)
 endfunction()
 
 # Usage:
-#   dt_chosen(<var> PROPERTY <prop>)
+#   dt_chosen(<var> PROPERTY <prop> [TARGET <target>])
 #
 # Get a node path for a /chosen node property.
 #
@@ -4441,13 +4429,13 @@ endfunction()
 #
 # <var>           : Return variable where the node path will be stored
 # PROPERTY <prop> : Chosen property
+# TARGET <target> : Optional target to retrieve devicetree information from
 function(dt_chosen var)
-  if(NOT DEFINED DEVICETREE_TARGET OR NOT TARGET "${DEVICETREE_TARGET}")
-    message(FATAL_ERROR "dt_chosen(${ARGV0} ...) devicetree is not available.")
-  endif()
-
   set(req_single_args "PROPERTY")
-  cmake_parse_arguments(DT_CHOSEN "" "${req_single_args}" "" ${ARGN})
+  set(single_args "TARGET")
+  cmake_parse_arguments(DT_CHOSEN "" "${req_single_args};${single_args}" "" ${ARGN})
+
+  dt_target_internal(DT_CHOSEN_TARGET)
 
   if(${ARGV0} IN_LIST req_single_args)
     message(FATAL_ERROR "dt_chosen(${ARGV0} ...) missing return parameter.")
@@ -4461,7 +4449,7 @@ function(dt_chosen var)
     endif()
   endforeach()
 
-  get_target_property(${var} "${DEVICETREE_TARGET}" "DT_CHOSEN|${DT_CHOSEN_PROPERTY}")
+  get_target_property(${var} ${DT_CHOSEN_TARGET} "DT_CHOSEN|${DT_CHOSEN_PROPERTY}")
 
   if(${${var}} STREQUAL ${var}-NOTFOUND)
     set(${var} PARENT_SCOPE)
@@ -4470,6 +4458,25 @@ function(dt_chosen var)
   endif()
 endfunction()
 
+# Internal helper. Check that the CMake target named by variable 'var' is valid
+# for use in other dt_* functions. If 'var' is undefined, set it to the default
+# name of "devicetree_target", which is initialized in cmake/modules/dts.cmake.
+# In general, a valid target is one that has been passed to zephyr_dt_import().
+function(dt_target_internal var)
+  if(NOT DEFINED ${var})
+    set(${var} devicetree_target)
+    set(${var} ${${var}} PARENT_SCOPE)
+  endif()
+
+  set(devicetree_imported FALSE)
+  if(TARGET ${${var}})
+    dt_path_internal_exists(devicetree_imported "/" ${${var}})
+  endif()
+  if(NOT devicetree_imported)
+    message(FATAL_ERROR "devicetree is not yet imported into target '${${var}}'")
+  endif()
+endfunction()
+
 # Internal helper. Canonicalizes a path 'path' into the output
 # variable 'var'. This resolves aliases, if any. Child nodes may be
 # accessed via alias as well. 'var' is left undefined if the path does
@@ -4490,17 +4497,17 @@ endfunction()
 #
 # Example usage:
 #
-#   dt_path_internal(ret "/foo/bar")     # sets ret to "/foo/bar"
-#   dt_path_internal(ret "my-alias")     # sets ret to "/foo/bar"
-#   dt_path_internal(ret "my-alias/baz") # sets ret to "/foo/bar/baz"
-#   dt_path_internal(ret "/blub")        # ret is undefined
-function(dt_path_internal var path)
+#   dt_path_internal(ret "/foo/bar" target)     # sets ret to "/foo/bar"
+#   dt_path_internal(ret "my-alias" target)     # sets ret to "/foo/bar"
+#   dt_path_internal(ret "my-alias/baz" target) # sets ret to "/foo/bar/baz"
+#   dt_path_internal(ret "/blub" target)        # ret is undefined
+function(dt_path_internal var path target)
   string(FIND "${path}" "/" slash_index)
 
   if("${slash_index}" EQUAL 0)
     # If the string starts with a slash, it should be an existing
     # canonical path.
-    dt_path_internal_exists(check "${path}")
+    dt_path_internal_exists(check "${path}" "${target}")
     if (check)
       set(${var} "${path}" PARENT_SCOPE)
       return()
@@ -4508,7 +4515,7 @@ function(dt_path_internal var path)
   else()
     # Otherwise, try to expand a leading alias.
     string(SUBSTRING "${path}" 0 "${slash_index}" alias_name)
-    dt_alias(alias_path PROPERTY "${alias_name}")
+    dt_alias(alias_path PROPERTY "${alias_name}" TARGET "${target}")
 
     # If there is a leading alias, append the rest of the string
     # onto it and see if that's an existing node.
@@ -4517,7 +4524,7 @@ function(dt_path_internal var path)
       if (NOT "${slash_index}" EQUAL -1)
         string(SUBSTRING "${path}" "${slash_index}" -1 rest)
       endif()
-      dt_path_internal_exists(expanded_path_exists "${alias_path}${rest}")
+      dt_path_internal_exists(expanded_path_exists "${alias_path}${rest}" "${target}")
       if (expanded_path_exists)
         set(${var} "${alias_path}${rest}" PARENT_SCOPE)
         return()
@@ -4532,8 +4539,8 @@ endfunction()
 # Internal helper. Set 'var' to TRUE if a canonical path 'path' refers
 # to an existing node. Set it to FALSE otherwise. See
 # dt_path_internal for a definition and examples of 'canonical' paths.
-function(dt_path_internal_exists var path)
-  get_target_property(path_prop "${DEVICETREE_TARGET}" "DT_NODE|${path}")
+function(dt_path_internal_exists var path target)
+  get_target_property(path_prop "${target}" "DT_NODE|${path}")
   if (path_prop)
     set(${var} TRUE PARENT_SCOPE)
   else()
@@ -4672,6 +4679,45 @@ function(zephyr_dt_preprocess)
   endif()
 endfunction()
 
+# Usage:
+#   zephyr_dt_import(EDT_PICKLE_FILE <file> TARGET <target>)
+#
+# Parse devicetree information and make it available to CMake, so that
+# it can be accessed by the dt_* CMake extensions from section 4.1.
+#
+# This requires running a Python script, which can take the output of
+# edtlib and generate a CMake source file from it. If that script fails,
+# a fatal error occurs.
+#
+# EDT_PICKLE_FILE <file> : Input edtlib.EDT object in pickle format
+# TARGET <target>        : Target to populate with devicetree properties
+#
+function(zephyr_dt_import)
+  set(req_single_args "EDT_PICKLE_FILE;TARGET")
+  cmake_parse_arguments(arg "" "${req_single_args}" "" ${ARGN})
+  zephyr_check_arguments_required_all(${CMAKE_CURRENT_FUNCTION} arg ${req_single_args})
+
+  set(gen_dts_cmake_script ${ZEPHYR_BASE}/scripts/dts/gen_dts_cmake.py)
+  set(gen_dts_cmake_output ${arg_EDT_PICKLE_FILE}.cmake)
+
+  if((${arg_EDT_PICKLE_FILE} IS_NEWER_THAN ${gen_dts_cmake_output}) OR
+     (${gen_dts_cmake_script} IS_NEWER_THAN ${gen_dts_cmake_output})
+  )
+    execute_process(
+      COMMAND ${PYTHON_EXECUTABLE} ${gen_dts_cmake_script}
+      --edt-pickle ${arg_EDT_PICKLE_FILE}
+      --cmake-out ${gen_dts_cmake_output}
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+      RESULT_VARIABLE ret
+      COMMAND_ERROR_IS_FATAL ANY
+    )
+  endif()
+  set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${gen_dts_cmake_script})
+
+  set(DEVICETREE_TARGET ${arg_TARGET})
+  include(${gen_dts_cmake_output})
+endfunction()
+
 ########################################################
 # 5. Zephyr linker functions
 ########################################################
diff --git a/scripts/dts/gen_dts_cmake.py b/scripts/dts/gen_dts_cmake.py
index 39496e74459..5dd4a8779d3 100755
--- a/scripts/dts/gen_dts_cmake.py
+++ b/scripts/dts/gen_dts_cmake.py
@@ -11,14 +11,12 @@
 
 The generated CMake file looks like this:
 
-  add_custom_target(${DEVICETREE_TARGET})
   set_target_properties(${DEVICETREE_TARGET} PROPERTIES
                         "DT_PROP|/soc|compatible" "vnd,soc;")
   ...
 
-It takes an input variable - DEVICETREE_TARGET - and creates a special
-CMake target with this name, which will contain various values in the
-devicetree as CMake target properties.
+It takes an input variable - DEVICETREE_TARGET - and saves various
+values in the devicetree as properties of this CMake target.
 
 Be careful:
 
@@ -176,8 +174,7 @@ def main():
         cmake_props
     )
     with open(args.cmake_out, "w", encoding="utf-8") as cmake_file:
-        print('add_custom_target(${DEVICETREE_TARGET})\n', *cmake_props,
-              sep='\n', file=cmake_file)
+        print("\n".join(cmake_props), file=cmake_file)
 
 
 if __name__ == "__main__":
diff --git a/share/sysbuild/cmake/modules/sysbuild_extensions.cmake b/share/sysbuild/cmake/modules/sysbuild_extensions.cmake
index dd9848fd4ad..9e618d340a5 100644
--- a/share/sysbuild/cmake/modules/sysbuild_extensions.cmake
+++ b/share/sysbuild/cmake/modules/sysbuild_extensions.cmake
@@ -512,8 +512,7 @@ function(ExternalZephyrProject_Cmake)
   endif()
   load_cache(IMAGE ${ZCMAKE_APPLICATION} BINARY_DIR ${BINARY_DIR})
   import_kconfig(CONFIG_ ${BINARY_DIR}/zephyr/.config TARGET ${ZCMAKE_APPLICATION})
-  set(DEVICETREE_TARGET ${ZCMAKE_APPLICATION}_devicetree_target)
-  include(${BINARY_DIR}/zephyr/dts.cmake)
+  zephyr_dt_import(EDT_PICKLE_FILE ${BINARY_DIR}/zephyr/edt.pickle TARGET ${ZCMAKE_APPLICATION})
 
   # This custom target informs CMake how the BYPRODUCTS are generated if a target
   # depends directly on the BYPRODUCT instead of depending on the image target.
@@ -765,86 +764,3 @@ function(sysbuild_images_order variable dependency_type)
   topological_sort(TARGETS ${SIS_IMAGES} PROPERTY_NAME ${property_name} RESULT sorted)
   set(${variable} ${sorted} PARENT_SCOPE)
 endfunction()
-
-# Internal macro for defining the sysbuild_dt_* CMake extensions, used to
-# retrieve devicetree information from a Zephyr based build system.
-#
-# It takes a dt_* function <name> and adds common wrapper code, which
-# adds an `IMAGE` argument to select the devicetree of a given <image>,
-# and forwards all other arguments to the original function, including
-# the sole return variable <var> - a common trait of the dt_* API.
-#
-# For additional documentation of each dt_* CMake extension,
-# see section 4.1. of cmake/modules/extensions.cmake.
-#
-macro(sysbuild_dt_function name)
-  function(sysbuild_${name} var)
-    cmake_parse_arguments(PARSE_ARGV 1 SBDT "" "IMAGE" "")
-    zephyr_check_arguments_required_all("sysbuild_${name}" SBDT IMAGE)
-
-    set(DEVICETREE_TARGET ${SBDT_IMAGE}_devicetree_target)
-    if(NOT TARGET ${SBDT_IMAGE} OR NOT TARGET ${DEVICETREE_TARGET})
-      message(FATAL_ERROR "sysbuild_${name}(...) image '${SBDT_IMAGE}' "
-                          "does not exist or its devicetree is not loaded yet"
-      )
-    endif()
-
-    cmake_language(CALL ${name} ${var} ${SBDT_UNPARSED_ARGUMENTS})
-    set(${var} "${${var}}" PARENT_SCOPE)
-  endfunction()
-endmacro()
-
-# Usage:
-#   sysbuild_dt_nodelabel(<var> IMAGE <image> NODELABEL <label> [REQUIRED])
-#
-sysbuild_dt_function(dt_nodelabel)
-
-# Usage:
-#   sysbuild_dt_alias(<var> IMAGE <image> PROPERTY <prop> [REQUIRED])
-#
-sysbuild_dt_function(dt_alias)
-
-# Usage:
-#   sysbuild_dt_node_exists(<var> IMAGE <image> PATH <path>)
-#
-sysbuild_dt_function(dt_node_exists)
-
-# Usage:
-#   sysbuild_dt_node_has_status(<var> IMAGE <image> PATH <path> STATUS <status>)
-#
-sysbuild_dt_function(dt_node_has_status)
-
-# Usage:
-#   sysbuild_dt_prop(<var> IMAGE <image> PATH <path> PROPERTY <prop> [INDEX <idx>] [REQUIRED])
-#
-sysbuild_dt_function(dt_prop)
-
-# Usage:
-#   sysbuild_dt_comp_path(<var> IMAGE <image> COMPATIBLE <compatible> [INDEX <idx>])
-#
-sysbuild_dt_function(dt_comp_path)
-
-# Usage:
-#   sysbuild_dt_num_regs(<var> IMAGE <image> PATH <path>)
-#
-sysbuild_dt_function(dt_num_regs)
-
-# Usage:
-#   sysbuild_dt_reg_addr(<var> IMAGE <image> PATH <path> [INDEX <idx>] [NAME <name>])
-#
-sysbuild_dt_function(dt_reg_addr)
-
-# Usage:
-#   sysbuild_dt_reg_size(<var> IMAGE <image> PATH <path> [INDEX <idx>] [NAME <name>])
-#
-sysbuild_dt_function(dt_reg_size)
-
-# Usage:
-#   sysbuild_dt_has_chosen(<var> IMAGE <image> PROPERTY <prop>)
-#
-sysbuild_dt_function(dt_has_chosen)
-
-# Usage:
-#   sysbuild_dt_chosen(<var> IMAGE <image> PROPERTY <prop>)
-#
-sysbuild_dt_function(dt_chosen)