80 files changed, 490 insertions, 490 deletions

diff --git a/product/clark/include/clark_core.h b/product/clark/include/clark_core.h
deleted file mode 100644
index bfda3730..00000000
--- a/product/clark/include/clark_core.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Arm SCP/MCP Software
- * Copyright (c) 2017-2019, Arm Limited and Contributors. All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#ifndef CLARK_CORE_H
-#define CLARK_CORE_H
-
-#include <fwk_assert.h>
-
-#define CLARK_CORE_PER_CLUSTER_MAX 8
-
-/* Clark only has one configuration, hence the constant values */
-#define CORES_PER_CLUSTER   4
-#define NUMBER_OF_CLUSTERS  2
-
-static inline unsigned int clark_core_get_cluster_count(void)
-{
-    return NUMBER_OF_CLUSTERS;
-}
-
-static inline unsigned int clark_core_get_core_per_cluster_count(
-    unsigned int cluster)
-{
-    fwk_assert(cluster < clark_core_get_cluster_count());
-
-    return CORES_PER_CLUSTER;
-}
-
-static inline unsigned int clark_core_get_core_count(void)
-{
-    return NUMBER_OF_CLUSTERS * CORES_PER_CLUSTER;
-}
-
-#endif /* CLARK_CORE_H */
diff --git a/product/clark/include/clark_power_domain.h b/product/clark/include/clark_power_domain.h
deleted file mode 100644
index ad5b09c9..00000000
--- a/product/clark/include/clark_power_domain.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * Arm SCP/MCP Software
- * Copyright (c) 2017-2019, Arm Limited and Contributors. All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- *
- * Description:
- *     CLARK System Support
- */
-
-#ifndef CLARK_POWER_DOMAIN_H
-#define CLARK_POWER_DOMAIN_H
-
-#include <mod_power_domain.h>
-
-/*! Additional CLARK power domain states */
-enum clark_power_domain_states {
-    CLARK_POWER_DOMAIN_STATE_FUNC_RET = MOD_PD_STATE_COUNT,
-    CLARK_POWER_DOMAIN_STATE_FULL_RET,
-    CLARK_POWER_DOMAIN_STATE_MEM_RET,
-    CLARK_POWER_DOMAIN_STATE_COUNT
-};
-
-/*! Power domain state masks */
-enum clark_power_domain_state_masks {
-    CLARK_POWER_DOMAIN_STATE_FUNC_RET_MASK =
-        (1 << CLARK_POWER_DOMAIN_STATE_FUNC_RET),
-    CLARK_POWER_DOMAIN_STATE_FULL_RET_MASK =
-        (1 << CLARK_POWER_DOMAIN_STATE_FULL_RET),
-    CLARK_POWER_DOMAIN_STATE_MEM_RET_MASK =
-        (1 << CLARK_POWER_DOMAIN_STATE_MEM_RET),
-};
-
-/*! Mask for the cluster valid power states */
-#define CLARK_CLUSTER_VALID_STATE_MASK ( \
-                                MOD_PD_STATE_OFF_MASK | \
-                                MOD_PD_STATE_ON_MASK | \
-                                MOD_PD_STATE_SLEEP_MASK | \
-                                CLARK_POWER_DOMAIN_STATE_MEM_RET_MASK | \
-                                CLARK_POWER_DOMAIN_STATE_FUNC_RET_MASK \
-                                )
-
-/*! Mask for the core valid power states */
-#define CLARK_CORE_VALID_STATE_MASK ( \
-                                MOD_PD_STATE_OFF_MASK | \
-                                MOD_PD_STATE_ON_MASK | \
-                                MOD_PD_STATE_SLEEP_MASK | \
-                                CLARK_POWER_DOMAIN_STATE_FULL_RET_MASK \
-                                )
-
-#endif /* CLARK_POWER_DOMAIN_H */
diff --git a/product/clark/include/clark_sds.h b/product/clark/include/clark_sds.h
deleted file mode 100644
index e95cf79f..00000000
--- a/product/clark/include/clark_sds.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Arm SCP/MCP Software
- * Copyright (c) 2017-2019, Arm Limited and Contributors. All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- */
-
-#ifndef CLARK_SDS_H
-#define CLARK_SDS_H
-
-#include <mod_sds.h>
-
-/*
- * Structure identifiers.
- */
-enum clark_sds_struct_id {
-    CLARK_SDS_CPU_INFO = 1 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
-    CLARK_SDS_FIRMWARE_VERSION = 2 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
-    CLARK_SDS_PLATFORM_ID = 3 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
-    CLARK_SDS_RESET_SYNDROME = 4 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
-    CLARK_SDS_FEATURE_AVAILABILITY =
-        5 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
-    CLARK_SDS_CPU_BOOTCTR = 6 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
-    CLARK_SDS_CPU_FLAGS = 7 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
-};
-
-/*
- * Structure sizes.
- */
-#define CLARK_SDS_CPU_INFO_SIZE 4
-#define CLARK_SDS_FIRMWARE_VERSION_SIZE 4
-#define CLARK_SDS_PLATFORM_ID_SIZE 8
-#define CLARK_SDS_RESET_SYNDROME_SIZE 4
-#define CLARK_SDS_FEATURE_AVAILABILITY_SIZE 4
-#define CLARK_SDS_CPU_BOOTCTR_SIZE 256
-#define CLARK_SDS_CPU_FLAGS_SIZE 256
-
-/*
- * Field masks and offsets for the CLARK_SDS_AP_CPU_INFO structure.
- */
-#define CLARK_SDS_CPU_INFO_PRIMARY_MASK 0xFFFFFFFF
-#define CLARK_SDS_CPU_INFO_PRIMARY_POS 0
-
-/*
- * Platform information
- */
-struct clark_sds_platid {
-    /* Subsystem part number */
-    uint32_t platform_identifier;
-    /* Platform type information */
-    uint32_t platform_type_identifier;
-};
-
-/*
- * Field masks and offsets for the CLARK_SDS_FEATURE_AVAILABILITY structure.
- */
-#define CLARK_SDS_FEATURE_FIRMWARE_MASK 0x1
-#define CLARK_SDS_FEATURE_DMC_MASK 0x2
-#define CLARK_SDS_FEATURE_MESSAGING_MASK 0x4
-
-#define CLARK_SDS_FEATURE_FIRMWARE_POS 0
-#define CLARK_SDS_FEATURE_DMC_POS 1
-#define CLARK_SDS_FEATURE_MESSAGING_POS 2
-
-#endif /* CLARK_SDS_H */
diff --git a/product/clark/include/scp_clark_mhu.h b/product/clark/include/scp_clark_mhu.h
deleted file mode 100644
index 86b19d07..00000000
--- a/product/clark/include/scp_clark_mhu.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Arm SCP/MCP Software
- * Copyright (c) 2017-2019, Arm Limited and Contributors. All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- *
- * Description:
- *     MHU module device indexes.
- */
-
-#ifndef SCP_CLARK_MHU_H
-#define SCP_CLARK_MHU_H
-
-enum scp_clark_mhu_device_idx {
-    SCP_CLARK_MHU_DEVICE_IDX_SCP_AP_S_CLUS0,
-    SCP_CLARK_MHU_DEVICE_IDX_SCP_AP_NS_CLUS0,
-    SCP_CLARK_MHU_DEVICE_IDX_COUNT
-};
-
-#endif /* SCP_CLARK_MHU_H */
diff --git a/product/clark/module/clark_system/include/mod_clark_system.h b/product/clark/module/clark_system/include/mod_clark_system.h
deleted file mode 100644
index 63ace7f0..00000000
--- a/product/clark/module/clark_system/include/mod_clark_system.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * Arm SCP/MCP Software
- * Copyright (c) 2017-2019, Arm Limited and Contributors. All rights reserved.
- *
- * SPDX-License-Identifier: BSD-3-Clause
- *
- * Description:
- *     CLARK System Support
- */
-
-#ifndef MOD_CLARK_SYSTEM_H
-#define MOD_CLARK_SYSTEM_H
-
-#include <mod_power_domain.h>
-
-/*!
- * \addtogroup GroupCLARKModule CLARK Product Modules
- * @{
- */
-
-/*!
- * \defgroup GroupCLARKSystem CLARK System Support
- * @{
- */
-
-/*!
- * \brief Additional CLARK system power states.
- */
-enum mod_clark_system_power_states {
-    MOD_CLARK_SYSTEM_POWER_STATE_SLEEP0 = MOD_PD_STATE_COUNT,
-    MOD_CLARK_SYSTEM_POWER_STATE_SLEEP1,
-    MOD_CLARK_SYSTEM_POWER_STATE_COUNT
-};
-
-/*!
- * \brief System power state masks.
- */
-enum mod_clark_system_power_state_masks {
-    MOD_CLARK_SYSTEM_POWER_STATE_SLEEP0_MASK =
-        (1 << MOD_CLARK_SYSTEM_POWER_STATE_SLEEP0),
-    MOD_CLARK_SYSTEM_POWER_STATE_SLEEP1_MASK =
-        (1 << MOD_CLARK_SYSTEM_POWER_STATE_SLEEP1),
-};
-
-/*!
- * \brief Indices of the interfaces exposed by the module.
- */
-enum mod_clark_system_api_idx {
-    /*! API index for the driver interface of the SYSTEM POWER module */
-    MOD_CLARK_SYSTEM_API_IDX_SYSTEM_POWER_DRIVER,
-
-    /*! Number of exposed interfaces */
-    MOD_CLARK_SYSTEM_API_COUNT
-};
-
-/*!
- * @}
- */
-
-/*!
- * @}
- */
-
-#endif /* MOD_CLARK_SYSTEM_H */
diff --git a/product/clark/include/fmw_cmsis.h b/product/rdn1e1/include/fmw_cmsis.h
index f904b953..f904b953 100644
--- a/product/clark/include/fmw_cmsis.h
+++ b/product/rdn1e1/include/fmw_cmsis.h
diff --git a/product/clark/include/mcp_clark_irq.h b/product/rdn1e1/include/mcp_rdn1e1_irq.h
index 1510ea86..91fe1f51 100644
--- a/product/clark/include/mcp_clark_irq.h
+++ b/product/rdn1e1/include/mcp_rdn1e1_irq.h
@@ -5,14 +5,14 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef MCP_CLARK_IRQ_H
-#define MCP_CLARK_IRQ_H
+#ifndef MCP_RDN1E1_IRQ_H
+#define MCP_RDN1E1_IRQ_H
 
 #include <fwk_interrupt.h>
 
 #define MCP_WDOG_IRQ FWK_INTERRUPT_NMI /* MCP Watchdog (SP805) */
 
-enum mcp_clark_interrupt {
+enum mcp_rdn1e1_interrupt {
     RESERVED0_IRQ              = 0, /* Reserved */
     CDBG_PWR_UP_REQ_IRQ        = 1, /* Coresight Debug Power Request */
     CSYS_PWR_UP_REQ_IRQ        = 2, /* Coresight System Power Request */
@@ -263,4 +263,4 @@ enum mcp_clark_interrupt {
     MCP_EXT_INTR31_IRQ         = 239  /* MCP Customer Extension */
 };
 
-#endif /* MCP_CLARK_IRQ_H */
+#endif /* MCP_RDN1E1_IRQ_H */
diff --git a/product/clark/include/mcp_clark_mmap.h b/product/rdn1e1/include/mcp_rdn1e1_mmap.h
index 6ca1baab..e5a5b18f 100644
--- a/product/clark/include/mcp_clark_mmap.h
+++ b/product/rdn1e1/include/mcp_rdn1e1_mmap.h
@@ -5,8 +5,8 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef MCP_CLARK_MMAP_H
-#define MCP_CLARK_MMAP_H
+#ifndef MCP_RDN1E1_MMAP_H
+#define MCP_RDN1E1_MMAP_H
 
 #include <stdint.h>
 
@@ -47,4 +47,4 @@
 #define MCP_MHU_MCP_SCP_SND           (MCP_MHU_SCP_BASE + 0x00000)
 #define MCP_MHU_MCP_SCP_RCV           (MCP_MHU_SCP_BASE + 0x10000)
 
-#endif /* MCP_CLARK_MMAP_H */
+#endif /* MCP_RDN1E1_MMAP_H */
diff --git a/product/clark/include/mcp_clark_mmap_mcp.h b/product/rdn1e1/include/mcp_rdn1e1_mmap_mcp.h
index 7445448a..7dd23bf1 100644
--- a/product/clark/include/mcp_clark_mmap_mcp.h
+++ b/product/rdn1e1/include/mcp_rdn1e1_mmap_mcp.h
@@ -5,11 +5,11 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef MCP_CLARK_MMAP_MCP_H
-#define MCP_CLARK_MMAP_MCP_H
+#ifndef MCP_RDN1E1_MMAP_MCP_H
+#define MCP_RDN1E1_MMAP_MCP_H
 
 #define MCP_ROM_BASE            0x00000000
 #define MCP_RAM0_BASE           0x00800000
 #define MCP_RAM1_BASE           0x20000000
 
-#endif /* MCP_CLARK_MMAP_MCP_H */
+#endif /* MCP_RDN1E1_MMAP_MCP_H */
diff --git a/product/clark/include/mcp_system_mmap_mcp.h b/product/rdn1e1/include/mcp_system_mmap_mcp.h
index 0f2604e5..79a55963 100644
--- a/product/clark/include/mcp_system_mmap_mcp.h
+++ b/product/rdn1e1/include/mcp_system_mmap_mcp.h
@@ -8,7 +8,7 @@
 #ifndef MCP_SYSTEM_MMAP_MCP_H
 #define MCP_SYSTEM_MMAP_MCP_H
 
-#include <mcp_clark_mmap_mcp.h>
+#include <mcp_rdn1e1_mmap_mcp.h>
 
 #define MCP_ROM_SIZE                 (64 * 1024)
 #define MCP_RAM0_SIZE                (64 * 1024)
diff --git a/product/rdn1e1/include/rdn1e1_core.h b/product/rdn1e1/include/rdn1e1_core.h
new file mode 100644
index 00000000..38a6c501
--- /dev/null
+++ b/product/rdn1e1/include/rdn1e1_core.h
@@ -0,0 +1,37 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2017-2019, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef RDN1E1_CORE_H
+#define RDN1E1_CORE_H
+
+#include <fwk_assert.h>
+
+#define RDN1E1_CORE_PER_CLUSTER_MAX 8
+
+/* RDN1E1 only has one configuration, hence the constant values */
+#define CORES_PER_CLUSTER   4
+#define NUMBER_OF_CLUSTERS  2
+
+static inline unsigned int rdn1e1_core_get_cluster_count(void)
+{
+    return NUMBER_OF_CLUSTERS;
+}
+
+static inline unsigned int rdn1e1_core_get_core_per_cluster_count(
+    unsigned int cluster)
+{
+    fwk_assert(cluster < rdn1e1_core_get_cluster_count());
+
+    return CORES_PER_CLUSTER;
+}
+
+static inline unsigned int rdn1e1_core_get_core_count(void)
+{
+    return NUMBER_OF_CLUSTERS * CORES_PER_CLUSTER;
+}
+
+#endif /* RDN1E1_CORE_H */
diff --git a/product/clark/include/clark_pik_cpu.h b/product/rdn1e1/include/rdn1e1_pik_cpu.h
index 8719e7ea..9383c916 100644
--- a/product/clark/include/clark_pik_cpu.h
+++ b/product/rdn1e1/include/rdn1e1_pik_cpu.h
@@ -5,8 +5,8 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef CLARK_PIK_CPU_H
-#define CLARK_PIK_CPU_H
+#ifndef RDN1E1_PIK_CPU_H
+#define RDN1E1_PIK_CPU_H
 
 #include <stdint.h>
 #include <fwk_macros.h>
@@ -89,4 +89,4 @@ struct pik_cpu_reg {
 
 #define PIK_CPU_PCL_CONFIG_NO_OF_PPU UINT32_C(0x0000000F)
 
-#endif  /* CLARK_PIK_CPU_H */
+#endif  /* RDN1E1_PIK_CPU_H */
diff --git a/product/clark/include/clark_pik_debug.h b/product/rdn1e1/include/rdn1e1_pik_debug.h
index 9de5ddbd..8a88ac68 100644
--- a/product/clark/include/clark_pik_debug.h
+++ b/product/rdn1e1/include/rdn1e1_pik_debug.h
@@ -5,8 +5,8 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef CLARK_PIK_DEBUG_H
-#define CLARK_PIK_DEBUG_H
+#ifndef RDN1E1_PIK_DEBUG_H
+#define RDN1E1_PIK_DEBUG_H
 
 #include <stdint.h>
 #include <fwk_macros.h>
@@ -47,4 +47,4 @@ struct pik_debug_reg {
     FWK_R   uint32_t ID3;
 };
 
-#endif  /* CLARK_PIK_DEBUG_H */
+#endif  /* RDN1E1_PIK_DEBUG_H */
diff --git a/product/clark/include/clark_pik_scp.h b/product/rdn1e1/include/rdn1e1_pik_scp.h
index e02c23f7..23350c4a 100644
--- a/product/clark/include/clark_pik_scp.h
+++ b/product/rdn1e1/include/rdn1e1_pik_scp.h
@@ -8,8 +8,8 @@
  *     SCP PIK registers
  */
 
-#ifndef CLARK_PIK_SCP_H
-#define CLARK_PIK_SCP_H
+#ifndef RDN1E1_PIK_SCP_H
+#define RDN1E1_PIK_SCP_H
 
 #include <stdint.h>
 #include <fwk_macros.h>
@@ -97,4 +97,4 @@ struct pik_scp_reg {
 
 #define PLL_STATUS_CPUPLLLOCK(CPU)  ((uint32_t)(1 << (CPU % 32)))
 
-#endif  /* CLARK_PIK_SCP_H */
+#endif  /* RDN1E1_PIK_SCP_H */
diff --git a/product/clark/include/clark_pik_system.h b/product/rdn1e1/include/rdn1e1_pik_system.h
index 47f6a823..b1c23a60 100644
--- a/product/clark/include/clark_pik_system.h
+++ b/product/rdn1e1/include/rdn1e1_pik_system.h
@@ -5,8 +5,8 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef CLARK_PIK_SYSTEM_H
-#define CLARK_PIK_SYSTEM_H
+#ifndef RDN1E1_PIK_SYSTEM_H
+#define RDN1E1_PIK_SYSTEM_H
 
 #include <stdint.h>
 #include <fwk_macros.h>
@@ -71,4 +71,4 @@ struct pik_system_reg {
     FWK_R   uint32_t        ID3;
 };
 
-#endif  /* CLARK_PIK_SYSTEM_H */
+#endif  /* RDN1E1_PIK_SYSTEM_H */
diff --git a/product/rdn1e1/include/rdn1e1_power_domain.h b/product/rdn1e1/include/rdn1e1_power_domain.h
new file mode 100644
index 00000000..f0d23327
--- /dev/null
+++ b/product/rdn1e1/include/rdn1e1_power_domain.h
@@ -0,0 +1,51 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2017-2019, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Description:
+ *     RDN1E1 System Support
+ */
+
+#ifndef RDN1E1_POWER_DOMAIN_H
+#define RDN1E1_POWER_DOMAIN_H
+
+#include <mod_power_domain.h>
+
+/*! Additional RDN1E1 power domain states */
+enum rdn1e1_power_domain_states {
+    RDN1E1_POWER_DOMAIN_STATE_FUNC_RET = MOD_PD_STATE_COUNT,
+    RDN1E1_POWER_DOMAIN_STATE_FULL_RET,
+    RDN1E1_POWER_DOMAIN_STATE_MEM_RET,
+    RDN1E1_POWER_DOMAIN_STATE_COUNT
+};
+
+/*! Power domain state masks */
+enum rdn1e1_power_domain_state_masks {
+    RDN1E1_POWER_DOMAIN_STATE_FUNC_RET_MASK =
+        (1 << RDN1E1_POWER_DOMAIN_STATE_FUNC_RET),
+    RDN1E1_POWER_DOMAIN_STATE_FULL_RET_MASK =
+        (1 << RDN1E1_POWER_DOMAIN_STATE_FULL_RET),
+    RDN1E1_POWER_DOMAIN_STATE_MEM_RET_MASK =
+        (1 << RDN1E1_POWER_DOMAIN_STATE_MEM_RET),
+};
+
+/*! Mask for the cluster valid power states */
+#define RDN1E1_CLUSTER_VALID_STATE_MASK ( \
+                                MOD_PD_STATE_OFF_MASK | \
+                                MOD_PD_STATE_ON_MASK | \
+                                MOD_PD_STATE_SLEEP_MASK | \
+                                RDN1E1_POWER_DOMAIN_STATE_MEM_RET_MASK | \
+                                RDN1E1_POWER_DOMAIN_STATE_FUNC_RET_MASK \
+                                )
+
+/*! Mask for the core valid power states */
+#define RDN1E1_CORE_VALID_STATE_MASK ( \
+                                MOD_PD_STATE_OFF_MASK | \
+                                MOD_PD_STATE_ON_MASK | \
+                                MOD_PD_STATE_SLEEP_MASK | \
+                                RDN1E1_POWER_DOMAIN_STATE_FULL_RET_MASK \
+                                )
+
+#endif /* RDN1E1_POWER_DOMAIN_H */
diff --git a/product/rdn1e1/include/rdn1e1_sds.h b/product/rdn1e1/include/rdn1e1_sds.h
new file mode 100644
index 00000000..019966b4
--- /dev/null
+++ b/product/rdn1e1/include/rdn1e1_sds.h
@@ -0,0 +1,65 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2017-2019, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef RDN1E1_SDS_H
+#define RDN1E1_SDS_H
+
+#include <mod_sds.h>
+
+/*
+ * Structure identifiers.
+ */
+enum rdn1e1_sds_struct_id {
+    RDN1E1_SDS_CPU_INFO = 1 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
+    RDN1E1_SDS_FIRMWARE_VERSION = 2 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
+    RDN1E1_SDS_PLATFORM_ID = 3 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
+    RDN1E1_SDS_RESET_SYNDROME = 4 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
+    RDN1E1_SDS_FEATURE_AVAILABILITY =
+        5 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
+    RDN1E1_SDS_CPU_BOOTCTR = 6 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
+    RDN1E1_SDS_CPU_FLAGS = 7 | (1 << MOD_SDS_ID_VERSION_MAJOR_POS),
+};
+
+/*
+ * Structure sizes.
+ */
+#define RDN1E1_SDS_CPU_INFO_SIZE 4
+#define RDN1E1_SDS_FIRMWARE_VERSION_SIZE 4
+#define RDN1E1_SDS_PLATFORM_ID_SIZE 8
+#define RDN1E1_SDS_RESET_SYNDROME_SIZE 4
+#define RDN1E1_SDS_FEATURE_AVAILABILITY_SIZE 4
+#define RDN1E1_SDS_CPU_BOOTCTR_SIZE 256
+#define RDN1E1_SDS_CPU_FLAGS_SIZE 256
+
+/*
+ * Field masks and offsets for the RDN1E1_SDS_AP_CPU_INFO structure.
+ */
+#define RDN1E1_SDS_CPU_INFO_PRIMARY_MASK 0xFFFFFFFF
+#define RDN1E1_SDS_CPU_INFO_PRIMARY_POS 0
+
+/*
+ * Platform information
+ */
+struct rdn1e1_sds_platid {
+    /* Subsystem part number */
+    uint32_t platform_identifier;
+    /* Platform type information */
+    uint32_t platform_type_identifier;
+};
+
+/*
+ * Field masks and offsets for the RDN1E1_SDS_FEATURE_AVAILABILITY structure.
+ */
+#define RDN1E1_SDS_FEATURE_FIRMWARE_MASK 0x1
+#define RDN1E1_SDS_FEATURE_DMC_MASK 0x2
+#define RDN1E1_SDS_FEATURE_MESSAGING_MASK 0x4
+
+#define RDN1E1_SDS_FEATURE_FIRMWARE_POS 0
+#define RDN1E1_SDS_FEATURE_DMC_POS 1
+#define RDN1E1_SDS_FEATURE_MESSAGING_POS 2
+
+#endif /* RDN1E1_SDS_H */
diff --git a/product/clark/include/scp_clark_irq.h b/product/rdn1e1/include/scp_rdn1e1_irq.h
index 49cddcd5..0340e9de 100644
--- a/product/clark/include/scp_clark_irq.h
+++ b/product/rdn1e1/include/scp_rdn1e1_irq.h
@@ -5,14 +5,14 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef SCP_CLARK_IRQ_H
-#define SCP_CLARK_IRQ_H
+#ifndef SCP_RDN1E1_IRQ_H
+#define SCP_RDN1E1_IRQ_H
 
 #include <fwk_interrupt.h>
 
 #define SCP_WDOG_IRQ FWK_INTERRUPT_NMI /* SCP Watchdog (SP805) */
 
-enum scp_clark_interrupt {
+enum scp_rdn1e1_interrupt {
     RESERVED0_IRQ              = 0, /* Reserved */
     CDBG_PWR_UP_REQ_IRQ        = 1, /* Coresight Debug Power Request */
     CSYS_PWR_UP_REQ_IRQ        = 2, /* Coresight System Power Request */
@@ -280,4 +280,4 @@ enum scp_clark_interrupt {
     SCP_EXT_INTR31_IRQ         = 239  /* SCP Customer Extension */
 };
 
-#endif /* SCP_CLARK_IRQ_H */
+#endif /* SCP_RDN1E1_IRQ_H */
diff --git a/product/rdn1e1/include/scp_rdn1e1_mhu.h b/product/rdn1e1/include/scp_rdn1e1_mhu.h
new file mode 100644
index 00000000..3bd6085c
--- /dev/null
+++ b/product/rdn1e1/include/scp_rdn1e1_mhu.h
@@ -0,0 +1,20 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2017-2019, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Description:
+ *     MHU module device indexes.
+ */
+
+#ifndef SCP_RDN1E1_MHU_H
+#define SCP_RDN1E1_MHU_H
+
+enum scp_rdn1e1_mhu_device_idx {
+    SCP_RDN1E1_MHU_DEVICE_IDX_SCP_AP_S_CLUS0,
+    SCP_RDN1E1_MHU_DEVICE_IDX_SCP_AP_NS_CLUS0,
+    SCP_RDN1E1_MHU_DEVICE_IDX_COUNT
+};
+
+#endif /* SCP_RDN1E1_MHU_H */
diff --git a/product/clark/include/scp_clark_mmap.h b/product/rdn1e1/include/scp_rdn1e1_mmap.h
index 1bd48bfa..de144545 100644
--- a/product/clark/include/scp_clark_mmap.h
+++ b/product/rdn1e1/include/scp_rdn1e1_mmap.h
@@ -5,8 +5,8 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef SCP_CLARK_MMAP_H
-#define SCP_CLARK_MMAP_H
+#ifndef SCP_RDN1E1_MMAP_H
+#define SCP_RDN1E1_MMAP_H
 
 #include <stdint.h>
 
@@ -84,4 +84,4 @@
 #define SCP_MHU_SCP_MCP_SND          (SCP_MHU_MCP_BASE + 0x00000)
 #define SCP_MHU_SCP_MCP_RCV          (SCP_MHU_MCP_BASE + 0x10000)
 
-#endif /* SCP_CLARK_MMAP_H */
+#endif /* SCP_RDN1E1_MMAP_H */
diff --git a/product/clark/include/scp_clark_mmap_scp.h b/product/rdn1e1/include/scp_rdn1e1_mmap_scp.h
index 429c3e46..51cf80dd 100644
--- a/product/clark/include/scp_clark_mmap_scp.h
+++ b/product/rdn1e1/include/scp_rdn1e1_mmap_scp.h
@@ -5,11 +5,11 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef SCP_CLARK_MMAP_SCP_H
-#define SCP_CLARK_MMAP_SCP_H
+#ifndef SCP_RDN1E1_MMAP_SCP_H
+#define SCP_RDN1E1_MMAP_SCP_H
 
 #define SCP_ROM_BASE                0x00000000
 #define SCP_RAM0_BASE               0x00800000
 #define SCP_RAM1_BASE               0x20000000
 
-#endif /* SCP_CLARK_MMAP_SCP_H */
+#endif /* SCP_RDN1E1_MMAP_SCP_H */
diff --git a/product/clark/include/scp_clark_pik.h b/product/rdn1e1/include/scp_rdn1e1_pik.h
index 9f3e6e32..17d13b2c 100644
--- a/product/clark/include/scp_clark_pik.h
+++ b/product/rdn1e1/include/scp_rdn1e1_pik.h
@@ -5,16 +5,16 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef SCP_CLARK_PIK_H
-#define SCP_CLARK_PIK_H
+#ifndef SCP_RDN1E1_PIK_H
+#define SCP_RDN1E1_PIK_H
 
-#include <scp_clark_mmap.h>
-#include <clark_pik_cpu.h>
-#include <clark_pik_scp.h>
-#include <clark_pik_system.h>
+#include <scp_rdn1e1_mmap.h>
+#include <rdn1e1_pik_cpu.h>
+#include <rdn1e1_pik_scp.h>
+#include <rdn1e1_pik_system.h>
 
 #define PIK_CLUSTER(IDX) ((struct pik_cpu_reg *) SCP_PIK_CLUSTER_BASE(IDX))
 #define PIK_SCP          ((struct pik_scp_reg *) SCP_PIK_SCP_BASE)
 #define PIK_SYSTEM       ((struct pik_system_reg *) SCP_PIK_SYSTEM_BASE)
 
-#endif /* SCP_CLARK_PIK_H */
+#endif /* SCP_RDN1E1_PIK_H */
diff --git a/product/clark/include/scp_clark_scmi.h b/product/rdn1e1/include/scp_rdn1e1_scmi.h
index 16594599..07d2dedd 100644
--- a/product/clark/include/scp_clark_scmi.h
+++ b/product/rdn1e1/include/scp_rdn1e1_scmi.h
@@ -8,21 +8,21 @@
  *     Definitions for SCMI and SMT module configurations.
  */
 
-#ifndef SCP_CLARK_SCMI_H
-#define SCP_CLARK_SCMI_H
+#ifndef SCP_RDN1E1_SCMI_H
+#define SCP_RDN1E1_SCMI_H
 
 /* SCMI agent identifiers */
-enum scp_clark_scmi_agent_id {
+enum scp_rdn1e1_scmi_agent_id {
     /* 0 is reserved for the platform */
     SCP_SCMI_AGENT_ID_OSPM = 1,
     SCP_SCMI_AGENT_ID_PSCI,
 };
 
 /* SCMI service indexes */
-enum scp_clark_scmi_service_idx {
-    SCP_CLARK_SCMI_SERVICE_IDX_PSCI,
-    SCP_CLARK_SCMI_SERVICE_IDX_OSPM,
-    SCP_CLARK_SCMI_SERVICE_IDX_COUNT,
+enum scp_rdn1e1_scmi_service_idx {
+    SCP_RDN1E1_SCMI_SERVICE_IDX_PSCI,
+    SCP_RDN1E1_SCMI_SERVICE_IDX_OSPM,
+    SCP_RDN1E1_SCMI_SERVICE_IDX_COUNT,
 };
 
-#endif /* SCP_CLARK_SCMI_H */
+#endif /* SCP_RDN1E1_SCMI_H */
diff --git a/product/clark/include/scp_software_mmap.h b/product/rdn1e1/include/scp_software_mmap.h
index 8d9f2a2f..081bf256 100644
--- a/product/clark/include/scp_software_mmap.h
+++ b/product/rdn1e1/include/scp_software_mmap.h
@@ -11,7 +11,7 @@
 #ifndef SCP_SOFTWARE_MMAP_H
 #define SCP_SOFTWARE_MMAP_H
 
-#include <scp_clark_mmap.h>
+#include <scp_rdn1e1_mmap.h>
 #include <fwk_macros.h>
 
 #define SCP_NOR_FLASH_BASE                  0x08000000
diff --git a/product/clark/include/scp_system_mmap.h b/product/rdn1e1/include/scp_system_mmap.h
index e941d5c7..08d4ff7f 100644
--- a/product/clark/include/scp_system_mmap.h
+++ b/product/rdn1e1/include/scp_system_mmap.h
@@ -8,7 +8,7 @@
 #ifndef SCP_SYSTEM_MMAP_H
 #define SCP_SYSTEM_MMAP_H
 
-#include <scp_clark_mmap.h>
+#include <scp_rdn1e1_mmap.h>
 
 #define SCP_PLAT_BASE           (SCP_SYS0_BASE + 0x3FFE0000)
 
diff --git a/product/clark/include/scp_system_mmap_scp.h b/product/rdn1e1/include/scp_system_mmap_scp.h
index b08da46b..1ab9a82d 100644
--- a/product/clark/include/scp_system_mmap_scp.h
+++ b/product/rdn1e1/include/scp_system_mmap_scp.h
@@ -8,7 +8,7 @@
 #ifndef SCP_SYSTEM_MMAP_SCP_H
 #define SCP_SYSTEM_MMAP_SCP_H
 
-#include <scp_clark_mmap_scp.h>
+#include <scp_rdn1e1_mmap_scp.h>
 
 #define SCP_ROM_SIZE                 (64 * 1024)
 #define SCP_RAM0_SIZE                (256 * 1024)
diff --git a/product/clark/include/system_clock.h b/product/rdn1e1/include/system_clock.h
index 43459353..43459353 100644
--- a/product/clark/include/system_clock.h
+++ b/product/rdn1e1/include/system_clock.h
diff --git a/product/clark/mcp_romfw/config_clock.c b/product/rdn1e1/mcp_romfw/config_clock.c
index 8e781762..8e781762 100644
--- a/product/clark/mcp_romfw/config_clock.c
+++ b/product/rdn1e1/mcp_romfw/config_clock.c
diff --git a/product/clark/mcp_romfw/config_log.c b/product/rdn1e1/mcp_romfw/config_log.c
index e510f47a..746a67dc 100644
--- a/product/clark/mcp_romfw/config_log.c
+++ b/product/rdn1e1/mcp_romfw/config_log.c
@@ -11,7 +11,7 @@
 #include <fwk_module_idx.h>
 #include <mod_log.h>
 #include <mod_pl011.h>
-#include <mcp_clark_mmap.h>
+#include <mcp_rdn1e1_mmap.h>
 
 /*
  * PL011 module
diff --git a/product/clark/mcp_romfw/config_clark_rom.c b/product/rdn1e1/mcp_romfw/config_rdn1e1_rom.c
index f63c8183..b647bf49 100644
--- a/product/clark/mcp_romfw/config_clark_rom.c
+++ b/product/rdn1e1/mcp_romfw/config_rdn1e1_rom.c
@@ -6,11 +6,11 @@
  */
 
 #include <fwk_module.h>
-#include <mod_clark_rom.h>
-#include <mcp_clark_mmap_mcp.h>
+#include <mod_rdn1e1_rom.h>
+#include <mcp_rdn1e1_mmap_mcp.h>
 
-const struct fwk_module_config config_clark_rom = {
-    .data = &((struct clark_rom_config) {
+const struct fwk_module_config config_rdn1e1_rom = {
+    .data = &((struct rdn1e1_rom_config) {
         .ramfw_base = MCP_RAM0_BASE,
         .load_ram_size = 0,
     })
diff --git a/product/clark/mcp_romfw/firmware.mk b/product/rdn1e1/mcp_romfw/firmware.mk
index 2f8e63d2..5ffe4a9c 100644
--- a/product/clark/mcp_romfw/firmware.mk
+++ b/product/rdn1e1/mcp_romfw/firmware.mk
@@ -15,11 +15,11 @@ BS_FIRMWARE_MODULES := \
     pl011 \
     log \
     clock \
-    clark_rom
+    rdn1e1_rom
 
 BS_FIRMWARE_SOURCES := \
     config_log.c \
     config_clock.c \
-    config_clark_rom.c
+    config_rdn1e1_rom.c
 
 include $(BS_DIR)/firmware.mk
diff --git a/product/clark/mcp_romfw/fmw_memory.ld.S b/product/rdn1e1/mcp_romfw/fmw_memory.ld.S
index 29cd4048..29cd4048 100644
--- a/product/clark/mcp_romfw/fmw_memory.ld.S
+++ b/product/rdn1e1/mcp_romfw/fmw_memory.ld.S
diff --git a/product/clark/module/clark_rom/include/mod_clark_rom.h b/product/rdn1e1/module/rdn1e1_rom/include/mod_rdn1e1_rom.h
index b20e296e..3fc600a9 100644
--- a/product/clark/module/clark_rom/include/mod_clark_rom.h
+++ b/product/rdn1e1/module/rdn1e1_rom/include/mod_rdn1e1_rom.h
@@ -5,25 +5,25 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#ifndef MOD_CLARK_ROM_H
-#define MOD_CLARK_ROM_H
+#ifndef MOD_RDN1E1_ROM_H
+#define MOD_RDN1E1_ROM_H
 
 #include <stdint.h>
 
 /*!
- * \addtogroup GroupCLARKModule CLARK Product Modules
+ * \addtogroup GroupRDN1E1Module RDN1E1 Product Modules
  * @{
  */
 
 /*!
- * \defgroup GroupCLARK ROM Support
+ * \defgroup GroupRDN1E1 ROM Support
  * @{
  */
 
 /*!
  * \brief Module configuration data.
  */
-struct clark_rom_config {
+struct rdn1e1_rom_config {
     /*! Base address of the RAM firmware image */
     const uintptr_t ramfw_base;
 
@@ -42,4 +42,4 @@ struct clark_rom_config {
  * @}
  */
 
-#endif /* MOD_CLARK_ROM_H */
+#endif /* MOD_RDN1E1_ROM_H */
diff --git a/product/clark/module/clark_system/src/Makefile b/product/rdn1e1/module/rdn1e1_rom/src/Makefile
index 9003732c..636c2e25 100644
--- a/product/clark/module/clark_system/src/Makefile
+++ b/product/rdn1e1/module/rdn1e1_rom/src/Makefile
@@ -5,7 +5,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 #
 
-BS_LIB_NAME := CLARK SYSTEM
-BS_LIB_SOURCES = mod_clark_system.c
+BS_LIB_NAME := RDN1E1 ROM
+BS_LIB_SOURCES := mod_rdn1e1_rom.c
 
 include $(BS_DIR)/lib.mk
diff --git a/product/clark/module/clark_rom/src/mod_clark_rom.c b/product/rdn1e1/module/rdn1e1_rom/src/mod_rdn1e1_rom.c
index 3a64a9ef..86f51f5b 100644
--- a/product/clark/module/clark_rom/src/mod_clark_rom.c
+++ b/product/rdn1e1/module/rdn1e1_rom/src/mod_rdn1e1_rom.c
@@ -13,9 +13,9 @@
 #include <fwk_module_idx.h>
 #include <fwk_thread.h>
 #include <mod_log.h>
-#include <mod_clark_rom.h>
+#include <mod_rdn1e1_rom.h>
 
-static const struct clark_rom_config *rom_config;
+static const struct rdn1e1_rom_config *rom_config;
 static struct mod_log_api *log_api;
 
 enum rom_event {
@@ -51,7 +51,7 @@ static void jump_to_ramfw(void)
 /*
  * Framework API
  */
-static int clark_rom_init(fwk_id_t module_id, unsigned int element_count,
+static int rdn1e1_rom_init(fwk_id_t module_id, unsigned int element_count,
     const void *data)
 {
     rom_config = data;
@@ -59,7 +59,7 @@ static int clark_rom_init(fwk_id_t module_id, unsigned int element_count,
     return FWK_SUCCESS;
 }
 
-static int clark_rom_bind(fwk_id_t id, unsigned int round)
+static int rdn1e1_rom_bind(fwk_id_t id, unsigned int round)
 {
     int status;
 
@@ -77,13 +77,13 @@ static int clark_rom_bind(fwk_id_t id, unsigned int round)
     return FWK_SUCCESS;
 }
 
-static int clark_rom_start(fwk_id_t id)
+static int rdn1e1_rom_start(fwk_id_t id)
 {
     int status;
     struct fwk_event event = {
-        .source_id = FWK_ID_MODULE(FWK_MODULE_IDX_CLARK_ROM),
-        .target_id = FWK_ID_MODULE(FWK_MODULE_IDX_CLARK_ROM),
-        .id = FWK_ID_EVENT(FWK_MODULE_IDX_CLARK_ROM, ROM_EVENT_RUN),
+        .source_id = FWK_ID_MODULE(FWK_MODULE_IDX_RDN1E1_ROM),
+        .target_id = FWK_ID_MODULE(FWK_MODULE_IDX_RDN1E1_ROM),
+        .id = FWK_ID_EVENT(FWK_MODULE_IDX_RDN1E1_ROM, ROM_EVENT_RUN),
     };
 
     status = fwk_thread_put_event(&event);
@@ -91,7 +91,7 @@ static int clark_rom_start(fwk_id_t id)
     return status;
 }
 
-static int clark_rom_process_event(const struct fwk_event *event,
+static int rdn1e1_rom_process_event(const struct fwk_event *event,
     struct fwk_event *resp)
 {
     log_api->log(MOD_LOG_GROUP_INFO, "[ROM] Launch RAM\n");
@@ -107,12 +107,12 @@ static int clark_rom_process_event(const struct fwk_event *event,
 }
 
 /* Module descriptor */
-const struct fwk_module module_clark_rom = {
-    .name = "CLARK_ROM",
+const struct fwk_module module_rdn1e1_rom = {
+    .name = "RDN1E1_ROM",
     .type = FWK_MODULE_TYPE_SERVICE,
     .event_count = ROM_EVENT_COUNT,
-    .init = clark_rom_init,
-    .bind = clark_rom_bind,
-    .start = clark_rom_start,
-    .process_event = clark_rom_process_event,
+    .init = rdn1e1_rom_init,
+    .bind = rdn1e1_rom_bind,
+    .start = rdn1e1_rom_start,
+    .process_event = rdn1e1_rom_process_event,
 };
diff --git a/product/rdn1e1/module/rdn1e1_system/include/mod_rdn1e1_system.h b/product/rdn1e1/module/rdn1e1_system/include/mod_rdn1e1_system.h
new file mode 100644
index 00000000..120d7b55
--- /dev/null
+++ b/product/rdn1e1/module/rdn1e1_system/include/mod_rdn1e1_system.h
@@ -0,0 +1,64 @@
+/*
+ * Arm SCP/MCP Software
+ * Copyright (c) 2017-2019, Arm Limited and Contributors. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Description:
+ *     RDN1E1 System Support
+ */
+
+#ifndef MOD_RDN1E1_SYSTEM_H
+#define MOD_RDN1E1_SYSTEM_H
+
+#include <mod_power_domain.h>
+
+/*!
+ * \addtogroup GroupRDN1E1Module RDN1E1 Product Modules
+ * @{
+ */
+
+/*!
+ * \defgroup GroupRDN1E1System RDN1E1 System Support
+ * @{
+ */
+
+/*!
+ * \brief Additional RDN1E1 system power states.
+ */
+enum mod_rdn1e1_system_power_states {
+    MOD_RDN1E1_SYSTEM_POWER_STATE_SLEEP0 = MOD_PD_STATE_COUNT,
+    MOD_RDN1E1_SYSTEM_POWER_STATE_SLEEP1,
+    MOD_RDN1E1_SYSTEM_POWER_STATE_COUNT
+};
+
+/*!
+ * \brief System power state masks.
+ */
+enum mod_rdn1e1_system_power_state_masks {
+    MOD_RDN1E1_SYSTEM_POWER_STATE_SLEEP0_MASK =
+        (1 << MOD_RDN1E1_SYSTEM_POWER_STATE_SLEEP0),
+    MOD_RDN1E1_SYSTEM_POWER_STATE_SLEEP1_MASK =
+        (1 << MOD_RDN1E1_SYSTEM_POWER_STATE_SLEEP1),
+};
+
+/*!
+ * \brief Indices of the interfaces exposed by the module.
+ */
+enum mod_rdn1e1_system_api_idx {
+    /*! API index for the driver interface of the SYSTEM POWER module */
+    MOD_RDN1E1_SYSTEM_API_IDX_SYSTEM_POWER_DRIVER,
+
+    /*! Number of exposed interfaces */
+    MOD_RDN1E1_SYSTEM_API_COUNT
+};
+
+/*!
+ * @}
+ */
+
+/*!
+ * @}
+ */
+
+#endif /* MOD_RDN1E1_SYSTEM_H */
diff --git a/product/clark/module/clark_rom/src/Makefile b/product/rdn1e1/module/rdn1e1_system/src/Makefile
index bebbdb87..edf10141 100644
--- a/product/clark/module/clark_rom/src/Makefile
+++ b/product/rdn1e1/module/rdn1e1_system/src/Makefile
@@ -5,7 +5,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 #
 
-BS_LIB_NAME := clark ROM
-BS_LIB_SOURCES := mod_clark_rom.c
+BS_LIB_NAME := RDN1E1 SYSTEM
+BS_LIB_SOURCES = mod_rdn1e1_system.c
 
-include $(BS_DIR)/lib.mk
\ No newline at end of file
+include $(BS_DIR)/lib.mk
diff --git a/product/clark/module/clark_system/src/mod_clark_system.c b/product/rdn1e1/module/rdn1e1_system/src/mod_rdn1e1_system.c
index 1abe4a66..22581032 100644
--- a/product/clark/module/clark_system/src/mod_clark_system.c
+++ b/product/rdn1e1/module/rdn1e1_system/src/mod_rdn1e1_system.c
@@ -5,7 +5,7 @@
  * SPDX-License-Identifier: BSD-3-Clause
  *
  * Description:
- *     CLARK System Support.
+ *     RDN1E1 System Support.
  */
 
 #include <stdint.h>
@@ -18,19 +18,19 @@
 #include <fwk_module_idx.h>
 #include <fwk_notification.h>
 #include <mod_clock.h>
-#include <mod_clark_system.h>
+#include <mod_rdn1e1_system.h>
 #include <mod_log.h>
 #include <mod_system_power.h>
 #include <mod_power_domain.h>
 #include <mod_ppu_v1.h>
-#include <clark_core.h>
-#include <clark_pik_scp.h>
-#include <scp_clark_irq.h>
-#include <scp_clark_mmap.h>
+#include <rdn1e1_core.h>
+#include <rdn1e1_pik_scp.h>
+#include <scp_rdn1e1_irq.h>
+#include <scp_rdn1e1_mmap.h>
 #include <config_clock.h>
 
 /* Module context */
-struct clark_system_ctx {
+struct rdn1e1_system_ctx {
     /* Pointer to the SCP PIK registers */
     struct pik_scp_reg *pik_scp_reg;
 
@@ -44,13 +44,13 @@ struct clark_system_ctx {
     struct mod_pd_restricted_api *mod_pd_restricted_api;
 };
 
-struct clark_system_isr {
+struct rdn1e1_system_isr {
     unsigned int interrupt;
     void (*handler)(void);
 };
 
-static struct clark_system_ctx clark_system_ctx;
-const struct fwk_module_config config_clark_system = { 0 };
+static struct rdn1e1_system_ctx rdn1e1_system_ctx;
+const struct fwk_module_config config_rdn1e1_system = { 0 };
 
 /*
  *  PPU Interrupt Service Routines for cluster and core power domains
@@ -64,49 +64,49 @@ static void ppu_cores_isr(unsigned int first, uint32_t status)
         core_idx = __builtin_ctz(status);
         status &= ~(1 << core_idx);
 
-        if ((first + core_idx) >= clark_core_get_core_count())
+        if ((first + core_idx) >= rdn1e1_core_get_core_count())
             continue;
 
-        clark_system_ctx.ppu_v1_isr_api->ppu_interrupt_handler(
+        rdn1e1_system_ctx.ppu_v1_isr_api->ppu_interrupt_handler(
             FWK_ID_ELEMENT(FWK_MODULE_IDX_PPU_V1, first + core_idx));
     }
 }
 
 static void ppu_cores_isr_0(void)
 {
-    ppu_cores_isr(0, clark_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[0]);
-    ppu_cores_isr(128, clark_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[4]);
+    ppu_cores_isr(0, rdn1e1_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[0]);
+    ppu_cores_isr(128, rdn1e1_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[4]);
 }
 
 static void ppu_cores_isr_1(void)
 {
-    ppu_cores_isr(32, clark_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[1]);
-    ppu_cores_isr(160, clark_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[5]);
+    ppu_cores_isr(32, rdn1e1_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[1]);
+    ppu_cores_isr(160, rdn1e1_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[5]);
 }
 
 static void ppu_cores_isr_2(void)
 {
-    ppu_cores_isr(64, clark_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[2]);
-    ppu_cores_isr(192, clark_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[6]);
+    ppu_cores_isr(64, rdn1e1_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[2]);
+    ppu_cores_isr(192, rdn1e1_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[6]);
 }
 
 static void ppu_cores_isr_3(void)
 {
-    ppu_cores_isr(96, clark_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[3]);
-    ppu_cores_isr(224, clark_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[7]);
+    ppu_cores_isr(96, rdn1e1_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[3]);
+    ppu_cores_isr(224, rdn1e1_system_ctx.pik_scp_reg->CPU_PPU_INT_STATUS[7]);
 }
 
 static void ppu_clusters_isr(void)
 {
-    uint32_t status = clark_system_ctx.pik_scp_reg->CLUS_PPU_INT_STATUS;
+    uint32_t status = rdn1e1_system_ctx.pik_scp_reg->CLUS_PPU_INT_STATUS;
     unsigned int cluster_idx;
 
     while (status != 0) {
         cluster_idx = __builtin_ctz(status);
 
-        clark_system_ctx.ppu_v1_isr_api->ppu_interrupt_handler(
+        rdn1e1_system_ctx.ppu_v1_isr_api->ppu_interrupt_handler(
             FWK_ID_ELEMENT(FWK_MODULE_IDX_PPU_V1,
-            clark_core_get_core_count() + cluster_idx));
+            rdn1e1_core_get_core_count() + cluster_idx));
 
         status &= ~(1 << cluster_idx);
     }
@@ -116,7 +116,7 @@ static void ppu_clusters_isr(void)
  *  PPU Interrupt Service Routine table
  */
 
-static struct clark_system_isr isrs[] = {
+static struct rdn1e1_system_isr isrs[] = {
     [0] = { .interrupt = PPU_CORES0_IRQ,
             .handler = ppu_cores_isr_0 },
     [1] = { .interrupt = PPU_CORES1_IRQ,
@@ -133,7 +133,7 @@ static struct clark_system_isr isrs[] = {
  * System power's driver API
  */
 
-static int clark_system_shutdown(
+static int rdn1e1_system_shutdown(
     enum mod_pd_system_shutdown system_shutdown)
 {
     NVIC_SystemReset();
@@ -142,20 +142,20 @@ static int clark_system_shutdown(
 }
 
 static const struct mod_system_power_driver_api
-    clark_system_system_power_driver_api = {
-    .system_shutdown = clark_system_shutdown,
+    rdn1e1_system_system_power_driver_api = {
+    .system_shutdown = rdn1e1_system_shutdown,
 };
 
 /*
  * Functions fulfilling the framework's module interface
  */
 
-static int clark_system_mod_init(fwk_id_t module_id, unsigned int unused,
+static int rdn1e1_system_mod_init(fwk_id_t module_id, unsigned int unused,
     const void *unused2)
 {
     int status;
     unsigned int idx;
-    struct clark_system_isr *isr;
+    struct rdn1e1_system_isr *isr;
 
     for (idx = 0; idx < FWK_ARRAY_SIZE(isrs); idx++) {
         isr = &isrs[idx];
@@ -164,41 +164,41 @@ static int clark_system_mod_init(fwk_id_t module_id, unsigned int unused,
             return status;
     }
 
-    clark_system_ctx.pik_scp_reg = (struct pik_scp_reg *)SCP_PIK_SCP_BASE;
+    rdn1e1_system_ctx.pik_scp_reg = (struct pik_scp_reg *)SCP_PIK_SCP_BASE;
 
     return FWK_SUCCESS;
 }
 
-static int clark_system_bind(fwk_id_t id, unsigned int round)
+static int rdn1e1_system_bind(fwk_id_t id, unsigned int round)
 {
     int status;
 
     if (round == 0) {
         status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_LOG),
-            FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &clark_system_ctx.log_api);
+            FWK_ID_API(FWK_MODULE_IDX_LOG, 0), &rdn1e1_system_ctx.log_api);
         if (status != FWK_SUCCESS)
             return status;
     }
 
     status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_POWER_DOMAIN),
         FWK_ID_API(FWK_MODULE_IDX_POWER_DOMAIN, MOD_PD_API_IDX_RESTRICTED),
-        &clark_system_ctx.mod_pd_restricted_api);
+        &rdn1e1_system_ctx.mod_pd_restricted_api);
     if (status != FWK_SUCCESS)
         return status;
 
     return fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_PPU_V1),
         FWK_ID_API(FWK_MODULE_IDX_PPU_V1, MOD_PPU_V1_API_IDX_ISR),
-        &clark_system_ctx.ppu_v1_isr_api);
+        &rdn1e1_system_ctx.ppu_v1_isr_api);
 }
 
-static int clark_system_process_bind_request(fwk_id_t requester_id,
+static int rdn1e1_system_process_bind_request(fwk_id_t requester_id,
     fwk_id_t pd_id, fwk_id_t api_id, const void **api)
 {
-    *api = &clark_system_system_power_driver_api;
+    *api = &rdn1e1_system_system_power_driver_api;
     return FWK_SUCCESS;
 }
 
-static int clark_system_start(fwk_id_t id)
+static int rdn1e1_system_start(fwk_id_t id)
 {
     int status;
 
@@ -209,17 +209,17 @@ static int clark_system_start(fwk_id_t id)
     if (status != FWK_SUCCESS)
         return status;
 
-    clark_system_ctx.log_api->log(MOD_LOG_GROUP_DEBUG,
-        "[CLARK SYSTEM] Requesting SYSTOP initialization...\n");
+    rdn1e1_system_ctx.log_api->log(MOD_LOG_GROUP_DEBUG,
+        "[RDN1E1 SYSTEM] Requesting SYSTOP initialization...\n");
 
     return
-        clark_system_ctx.mod_pd_restricted_api->set_composite_state_async(
+        rdn1e1_system_ctx.mod_pd_restricted_api->set_composite_state_async(
             FWK_ID_ELEMENT(FWK_MODULE_IDX_POWER_DOMAIN, 0), false,
             MOD_PD_COMPOSITE_STATE(MOD_PD_LEVEL_2, 0, MOD_PD_STATE_ON,
                                    MOD_PD_STATE_OFF, MOD_PD_STATE_OFF));
 }
 
-int clark_system_process_notification(const struct fwk_event *event,
+int rdn1e1_system_process_notification(const struct fwk_event *event,
     struct fwk_event *resp_event)
 {
     int status;
@@ -236,10 +236,10 @@ int clark_system_process_notification(const struct fwk_event *event,
      * only
      */
     if (params->new_state == MOD_CLOCK_STATE_RUNNING) {
-        clark_system_ctx.log_api->log(MOD_LOG_GROUP_DEBUG,
-            "[CLARK SYSTEM] Initializing the primary core...\n");
+        rdn1e1_system_ctx.log_api->log(MOD_LOG_GROUP_DEBUG,
+            "[RDN1E1 SYSTEM] Initializing the primary core...\n");
 
-        mod_pd_restricted_api = clark_system_ctx.mod_pd_restricted_api;
+        mod_pd_restricted_api = rdn1e1_system_ctx.mod_pd_restricted_api;
 
         status =  mod_pd_restricted_api->set_composite_state_async(
             FWK_ID_ELEMENT(FWK_MODULE_IDX_POWER_DOMAIN, 0),
@@ -257,13 +257,13 @@ int clark_system_process_notification(const struct fwk_event *event,
     return FWK_SUCCESS;
 }
 
-const struct fwk_module module_clark_system = {
-    .name = "CLARK_SYSTEM",
+const struct fwk_module module_rdn1e1_system = {
+    .name = "RDN1E1_SYSTEM",
     .type = FWK_MODULE_TYPE_DRIVER,
-    .api_count = MOD_CLARK_SYSTEM_API_COUNT,
-    .init = clark_system_mod_init,
-    .bind = clark_system_bind,
-    .process_bind_request = clark_system_process_bind_request,
-    .process_notification = clark_system_process_notification,
-    .start = clark_system_start,
+    .api_count = MOD_RDN1E1_SYSTEM_API_COUNT,
+    .init = rdn1e1_system_mod_init,
+    .bind = rdn1e1_system_bind,
+    .process_bind_request = rdn1e1_system_process_bind_request,
+    .process_notification = rdn1e1_system_process_notification,
+    .start = rdn1e1_system_start,
 };
diff --git a/product/clark/product.mk b/product/rdn1e1/product.mk
index ed9aa518..c2965d88 100644
--- a/product/clark/product.mk
+++ b/product/rdn1e1/product.mk
@@ -4,10 +4,10 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 #
-# Platforms supported by the clark product: SGI-Clark.
+# Platforms supported by the rdn1e1 product: RDN1E1.
 #
 
-BS_PRODUCT_NAME := clark
+BS_PRODUCT_NAME := rdn1e1
 BS_FIRMWARE_LIST := scp_romfw \
                     scp_ramfw \
                     mcp_romfw
diff --git a/product/clark/scp_ramfw/RTX_Config.h b/product/rdn1e1/scp_ramfw/RTX_Config.h
index 688d384f..688d384f 100644
--- a/product/clark/scp_ramfw/RTX_Config.h
+++ b/product/rdn1e1/scp_ramfw/RTX_Config.h
diff --git a/product/clark/scp_ramfw/config_apcontext.c b/product/rdn1e1/scp_ramfw/config_apcontext.c
index 250d5209..250d5209 100644
--- a/product/clark/scp_ramfw/config_apcontext.c
+++ b/product/rdn1e1/scp_ramfw/config_apcontext.c
diff --git a/product/clark/scp_ramfw/config_armv7m_mpu.c b/product/rdn1e1/scp_ramfw/config_armv7m_mpu.c
index 9943b764..5bb13394 100644
--- a/product/clark/scp_ramfw/config_armv7m_mpu.c
+++ b/product/rdn1e1/scp_ramfw/config_armv7m_mpu.c
@@ -5,8 +5,8 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include <scp_clark_mmap.h>
-#include <scp_clark_mmap_scp.h>
+#include <scp_rdn1e1_mmap.h>
+#include <scp_rdn1e1_mmap_scp.h>
 #include <mod_armv7m_mpu.h>
 #include <fwk_macros.h>
 #include <fwk_module.h>
diff --git a/product/clark/scp_ramfw/config_clock.c b/product/rdn1e1/scp_ramfw/config_clock.c
index 32a76ad1..e80cc4d7 100644
--- a/product/clark/scp_ramfw/config_clock.c
+++ b/product/rdn1e1/scp_ramfw/config_clock.c
@@ -12,7 +12,7 @@
 #include <mod_css_clock.h>
 #include <mod_pik_clock.h>
 #include <mod_power_domain.h>
-#include <clark_core.h>
+#include <rdn1e1_core.h>
 #include <system_clock.h>
 #include <config_clock.h>
 #include <config_power_domain.h>
@@ -58,7 +58,7 @@ static const struct fwk_element *clock_get_dev_desc_table(fwk_id_t module_id)
             (struct mod_clock_dev_config *)clock_dev_desc_table[i].data;
         dev_config->pd_source_id = fwk_id_build_element_id(
             fwk_module_id_power_domain,
-            clark_core_get_core_count() + PD_STATIC_DEV_IDX_SYSTOP);
+            rdn1e1_core_get_core_count() + PD_STATIC_DEV_IDX_SYSTOP);
     }
 
     return clock_dev_desc_table;
diff --git a/product/clark/scp_ramfw/config_clock.h b/product/rdn1e1/scp_ramfw/config_clock.h
index 2f66c42b..2f66c42b 100644
--- a/product/clark/scp_ramfw/config_clock.h
+++ b/product/rdn1e1/scp_ramfw/config_clock.h
diff --git a/product/clark/scp_ramfw/config_cmn600.c b/product/rdn1e1/scp_ramfw/config_cmn600.c
index 03371c7e..fca44648 100644
--- a/product/clark/scp_ramfw/config_cmn600.c
+++ b/product/rdn1e1/scp_ramfw/config_cmn600.c
@@ -9,7 +9,7 @@
 #include <fwk_module.h>
 #include <fwk_module_idx.h>
 #include <mod_cmn600.h>
-#include <scp_clark_mmap.h>
+#include <scp_rdn1e1_mmap.h>
 #include <config_clock.h>
 
 #define ROOT_NODE_OFFSET 0xD00000
diff --git a/product/clark/scp_ramfw/config_css_clock.c b/product/rdn1e1/scp_ramfw/config_css_clock.c
index 63f3ecd4..48386797 100644
--- a/product/clark/scp_ramfw/config_css_clock.c
+++ b/product/rdn1e1/scp_ramfw/config_css_clock.c
@@ -13,7 +13,7 @@
 #include <mod_css_clock.h>
 #include <mod_system_pll.h>
 #include <mod_pik_clock.h>
-#include <scp_clark_pik.h>
+#include <scp_rdn1e1_pik.h>
 #include <config_clock.h>
 
 static const struct mod_css_clock_rate rate_table_cpu_group_0[] = {
diff --git a/product/clark/scp_ramfw/config_ddr_phy500.c b/product/rdn1e1/scp_ramfw/config_ddr_phy500.c
index 06fca4c5..06fca4c5 100644
--- a/product/clark/scp_ramfw/config_ddr_phy500.c
+++ b/product/rdn1e1/scp_ramfw/config_ddr_phy500.c
diff --git a/product/clark/scp_ramfw/config_dmc620.c b/product/rdn1e1/scp_ramfw/config_dmc620.c
index f4cf3546..f4cf3546 100644
--- a/product/clark/scp_ramfw/config_dmc620.c
+++ b/product/rdn1e1/scp_ramfw/config_dmc620.c
diff --git a/product/clark/scp_ramfw/config_dvfs.c b/product/rdn1e1/scp_ramfw/config_dvfs.c
index 3ef546f6..3ef546f6 100644
--- a/product/clark/scp_ramfw/config_dvfs.c
+++ b/product/rdn1e1/scp_ramfw/config_dvfs.c
diff --git a/product/clark/scp_ramfw/config_log.c b/product/rdn1e1/scp_ramfw/config_log.c
index 7ef1e530..9f39c5e8 100644
--- a/product/clark/scp_ramfw/config_log.c
+++ b/product/rdn1e1/scp_ramfw/config_log.c
@@ -11,7 +11,7 @@
 #include <fwk_module_idx.h>
 #include <mod_log.h>
 #include <mod_pl011.h>
-#include <scp_clark_mmap.h>
+#include <scp_rdn1e1_mmap.h>
 
 /*
  * PL011 module
diff --git a/product/clark/scp_ramfw/config_mhu2.c b/product/rdn1e1/scp_ramfw/config_mhu2.c
index e6331216..76f1a590 100644
--- a/product/clark/scp_ramfw/config_mhu2.c
+++ b/product/rdn1e1/scp_ramfw/config_mhu2.c
@@ -9,12 +9,12 @@
 #include <fwk_id.h>
 #include <fwk_module.h>
 #include <mod_mhu2.h>
-#include <scp_clark_irq.h>
-#include <scp_clark_mmap.h>
-#include <scp_clark_mhu.h>
+#include <scp_rdn1e1_irq.h>
+#include <scp_rdn1e1_mmap.h>
+#include <scp_rdn1e1_mhu.h>
 
 static const struct fwk_element mhu_element_table[] = {
-    [SCP_CLARK_MHU_DEVICE_IDX_SCP_AP_S_CLUS0] = {
+    [SCP_RDN1E1_MHU_DEVICE_IDX_SCP_AP_S_CLUS0] = {
         .name = "MHU_SCP_AP_S",
         .sub_element_count = 1,
         .data = &((struct mod_mhu2_channel_config) {
@@ -24,7 +24,7 @@ static const struct fwk_element mhu_element_table[] = {
             .channel = 0,
         })
     },
-    [SCP_CLARK_MHU_DEVICE_IDX_SCP_AP_NS_CLUS0] = {
+    [SCP_RDN1E1_MHU_DEVICE_IDX_SCP_AP_NS_CLUS0] = {
         .name = "MHU_SCP_AP_NS",
         .sub_element_count = 1,
         .data = &((struct mod_mhu2_channel_config) {
@@ -34,7 +34,7 @@ static const struct fwk_element mhu_element_table[] = {
             .channel = 0,
         })
     },
-    [SCP_CLARK_MHU_DEVICE_IDX_COUNT] = { 0 },
+    [SCP_RDN1E1_MHU_DEVICE_IDX_COUNT] = { 0 },
 };
 
 static const struct fwk_element *mhu_get_element_table(fwk_id_t module_id)
diff --git a/product/clark/scp_ramfw/config_mock_psu.c b/product/rdn1e1/scp_ramfw/config_mock_psu.c
index 3c72b9ad..3c72b9ad 100644
--- a/product/clark/scp_ramfw/config_mock_psu.c
+++ b/product/rdn1e1/scp_ramfw/config_mock_psu.c
diff --git a/product/clark/scp_ramfw/config_pik_clock.c b/product/rdn1e1/scp_ramfw/config_pik_clock.c
index 22767826..49e39441 100644
--- a/product/clark/scp_ramfw/config_pik_clock.c
+++ b/product/rdn1e1/scp_ramfw/config_pik_clock.c
@@ -10,8 +10,8 @@
 #include <fwk_macros.h>
 #include <fwk_module.h>
 #include <mod_pik_clock.h>
-#include <clark_pik_system.h>
-#include <scp_clark_pik.h>
+#include <rdn1e1_pik_system.h>
+#include <scp_rdn1e1_pik.h>
 #include <system_clock.h>
 #include <config_clock.h>
 
diff --git a/product/clark/scp_ramfw/config_power_domain.c b/product/rdn1e1/scp_ramfw/config_power_domain.c
index e08e4e7c..15ab225a 100644
--- a/product/clark/scp_ramfw/config_power_domain.c
+++ b/product/rdn1e1/scp_ramfw/config_power_domain.c
@@ -16,8 +16,8 @@
 #include <mod_system_power.h>
 #include <mod_power_domain.h>
 #include <mod_ppu_v1.h>
-#include <clark_power_domain.h>
-#include <clark_core.h>
+#include <rdn1e1_power_domain.h>
+#include <rdn1e1_core.h>
 #include <config_ppu_v0.h>
 #include <config_power_domain.h>
 
@@ -53,7 +53,7 @@ static const uint32_t toplevel_allowed_state_mask_table[] = {
 static const uint32_t cluster_pd_allowed_state_mask_table[] = {
     [MOD_PD_STATE_OFF] = MOD_PD_STATE_OFF_MASK,
     [MOD_PD_STATE_ON] =
-        CLARK_CLUSTER_VALID_STATE_MASK & (~MOD_PD_STATE_SLEEP_MASK),
+        RDN1E1_CLUSTER_VALID_STATE_MASK & (~MOD_PD_STATE_SLEEP_MASK),
     [MOD_SYSTEM_POWER_POWER_STATE_SLEEP0] = MOD_PD_STATE_OFF_MASK,
     [MOD_SYSTEM_POWER_POWER_STATE_SLEEP1] = MOD_PD_STATE_OFF_MASK
 };
@@ -61,17 +61,17 @@ static const uint32_t cluster_pd_allowed_state_mask_table[] = {
 /* Mask of the allowed states for a core depending on the cluster states. */
 static const uint32_t core_pd_allowed_state_mask_table[] = {
     [MOD_PD_STATE_OFF] = MOD_PD_STATE_OFF_MASK | MOD_PD_STATE_SLEEP_MASK,
-    [MOD_PD_STATE_ON] = CLARK_CORE_VALID_STATE_MASK,
+    [MOD_PD_STATE_ON] = RDN1E1_CORE_VALID_STATE_MASK,
     [MOD_PD_STATE_SLEEP] = MOD_PD_STATE_OFF_MASK | MOD_PD_STATE_SLEEP_MASK,
-    [CLARK_POWER_DOMAIN_STATE_FUNC_RET] = CLARK_CORE_VALID_STATE_MASK,
-    [CLARK_POWER_DOMAIN_STATE_MEM_RET] = MOD_PD_STATE_OFF_MASK
+    [RDN1E1_POWER_DOMAIN_STATE_FUNC_RET] = RDN1E1_CORE_VALID_STATE_MASK,
+    [RDN1E1_POWER_DOMAIN_STATE_MEM_RET] = MOD_PD_STATE_OFF_MASK
 };
 
 /* Power module specific configuration data (none) */
 static const struct mod_power_domain_config
-    clark_power_domain_config = { 0 };
+    rdn1e1_power_domain_config = { 0 };
 
-static struct fwk_element clark_power_domain_static_element_table[] = {
+static struct fwk_element rdn1e1_power_domain_static_element_table[] = {
     [PD_STATIC_DEV_IDX_CLUSTER0] = {
         .name = "CLUS0",
         .data = &((struct mod_power_domain_element_config) {
@@ -134,7 +134,7 @@ static struct fwk_element clark_power_domain_static_element_table[] = {
 /*
  * Function definitions with internal linkage
  */
-static const struct fwk_element *clark_power_domain_get_element_table
+static const struct fwk_element *rdn1e1_power_domain_get_element_table
     (fwk_id_t module_id)
 {
     struct fwk_element *element_table, *element;
@@ -145,12 +145,12 @@ static const struct fwk_element *clark_power_domain_get_element_table
     unsigned int cluster_count;
     unsigned int core_element_count = 0;
 
-    core_count = clark_core_get_core_count();
-    cluster_count = clark_core_get_cluster_count();
+    core_count = rdn1e1_core_get_core_count();
+    cluster_count = rdn1e1_core_get_cluster_count();
 
     element_table = fwk_mm_calloc(
         core_count
-        + FWK_ARRAY_SIZE(clark_power_domain_static_element_table)
+        + FWK_ARRAY_SIZE(rdn1e1_power_domain_static_element_table)
         + 1, /* Terminator */
         sizeof(struct fwk_element));
     if (element_table == NULL)
@@ -163,7 +163,7 @@ static const struct fwk_element *clark_power_domain_get_element_table
 
     for (cluster_idx = 0; cluster_idx < cluster_count; cluster_idx++) {
         for (core_idx = 0;
-             core_idx < clark_core_get_core_per_cluster_count(cluster_idx);
+             core_idx < rdn1e1_core_get_core_per_cluster_count(cluster_idx);
              core_idx++) {
 
             element = &element_table[core_element_count];
@@ -196,15 +196,15 @@ static const struct fwk_element *clark_power_domain_get_element_table
 
         /* Define the driver id for the cluster */
         pd_config = (struct mod_power_domain_element_config *)
-            clark_power_domain_static_element_table[cluster_idx].data;
+            rdn1e1_power_domain_static_element_table[cluster_idx].data;
         pd_config->driver_id =
             FWK_ID_ELEMENT(FWK_MODULE_IDX_PPU_V1,
                            (core_count + cluster_idx));
     }
 
     memcpy(element_table + core_count,
-           clark_power_domain_static_element_table,
-           sizeof(clark_power_domain_static_element_table));
+           rdn1e1_power_domain_static_element_table,
+           sizeof(rdn1e1_power_domain_static_element_table));
 
     return element_table;
 }
@@ -213,6 +213,6 @@ static const struct fwk_element *clark_power_domain_get_element_table
  * Power module configuration data
  */
 const struct fwk_module_config config_power_domain = {
-    .get_element_table = clark_power_domain_get_element_table,
-    .data = &clark_power_domain_config,
+    .get_element_table = rdn1e1_power_domain_get_element_table,
+    .data = &rdn1e1_power_domain_config,
 };
diff --git a/product/clark/scp_ramfw/config_power_domain.h b/product/rdn1e1/scp_ramfw/config_power_domain.h
index c71ae55a..ce93baa4 100644
--- a/product/clark/scp_ramfw/config_power_domain.h
+++ b/product/rdn1e1/scp_ramfw/config_power_domain.h
@@ -10,7 +10,7 @@
 
 /*
  * Power domain indices for the statically defined domains used for:
- * - Indexing the domains in the clark_power_domain_static_element_table
+ * - Indexing the domains in the rdn1e1_power_domain_static_element_table
  * - Indexing the SYSTOP children in the power domain tree
  *
  * When calculating a power domain element index, use the formula:
diff --git a/product/clark/scp_ramfw/config_ppu_v0.c b/product/rdn1e1/scp_ramfw/config_ppu_v0.c
index c2426fc2..995f34d3 100644
--- a/product/clark/scp_ramfw/config_ppu_v0.c
+++ b/product/rdn1e1/scp_ramfw/config_ppu_v0.c
@@ -9,8 +9,8 @@
 #include <fwk_module.h>
 #include <mod_ppu_v0.h>
 #include <config_ppu_v0.h>
-#include <scp_clark_irq.h>
-#include <scp_clark_mmap.h>
+#include <scp_rdn1e1_irq.h>
+#include <scp_rdn1e1_mmap.h>
 
 static struct fwk_element ppu_v0_element_table[] = {
     [PPU_V0_ELEMENT_IDX_DBGTOP] = {
diff --git a/product/clark/scp_ramfw/config_ppu_v0.h b/product/rdn1e1/scp_ramfw/config_ppu_v0.h
index 7858b2b1..7858b2b1 100644
--- a/product/clark/scp_ramfw/config_ppu_v0.h
+++ b/product/rdn1e1/scp_ramfw/config_ppu_v0.h
diff --git a/product/clark/scp_ramfw/config_ppu_v1.c b/product/rdn1e1/scp_ramfw/config_ppu_v1.c
index e12831b8..a6e791a0 100644
--- a/product/clark/scp_ramfw/config_ppu_v1.c
+++ b/product/rdn1e1/scp_ramfw/config_ppu_v1.c
@@ -16,9 +16,9 @@
 #include <mod_cmn600.h>
 #include <mod_power_domain.h>
 #include <mod_ppu_v1.h>
-#include <clark_core.h>
-#include <scp_clark_irq.h>
-#include <scp_clark_mmap.h>
+#include <rdn1e1_core.h>
+#include <scp_rdn1e1_irq.h>
+#include <scp_rdn1e1_mmap.h>
 #include <config_power_domain.h>
 
 /* Maximum PPU core name size including the null terminator */
@@ -66,8 +66,8 @@ static const struct fwk_element *ppu_v1_get_element_table(fwk_id_t module_id)
     unsigned int cluster_count;
     unsigned int core_element_count = 0;
 
-    core_count = clark_core_get_core_count();
-    cluster_count = clark_core_get_cluster_count();
+    core_count = rdn1e1_core_get_core_count();
+    cluster_count = rdn1e1_core_get_cluster_count();
 
     assert(cluster_count == FWK_ARRAY_SIZE(cluster_idx_to_node_id));
 
@@ -91,7 +91,7 @@ static const struct fwk_element *ppu_v1_get_element_table(fwk_id_t module_id)
 
     for (cluster_idx = 0; cluster_idx < cluster_count; cluster_idx++) {
         for (core_idx = 0;
-             core_idx < clark_core_get_core_per_cluster_count(cluster_idx);
+             core_idx < rdn1e1_core_get_core_per_cluster_count(cluster_idx);
              core_idx++) {
             element = &element_table[core_element_count];
             pd_config = &pd_config_table[core_element_count];
diff --git a/product/clark/scp_ramfw/config_psu.c b/product/rdn1e1/scp_ramfw/config_psu.c
index 8c5740e5..8c5740e5 100644
--- a/product/clark/scp_ramfw/config_psu.c
+++ b/product/rdn1e1/scp_ramfw/config_psu.c
diff --git a/product/clark/scp_ramfw/config_scmi.c b/product/rdn1e1/scp_ramfw/config_scmi.c
index 6e836838..0da2fee1 100644
--- a/product/clark/scp_ramfw/config_scmi.c
+++ b/product/rdn1e1/scp_ramfw/config_scmi.c
@@ -10,37 +10,37 @@
 #include <fwk_macros.h>
 #include <fwk_module.h>
 #include <fwk_module_idx.h>
-#include <scp_clark_scmi.h>
+#include <scp_rdn1e1_scmi.h>
 #include <mod_scmi.h>
 #include <internal/scmi.h>
 #include <mod_smt.h>
 
 static const struct fwk_element service_table[] = {
-    [SCP_CLARK_SCMI_SERVICE_IDX_PSCI] = {
+    [SCP_RDN1E1_SCMI_SERVICE_IDX_PSCI] = {
         .name = "SERVICE0",
         .data = &((struct mod_scmi_service_config) {
             .transport_id = FWK_ID_ELEMENT_INIT(
                 FWK_MODULE_IDX_SMT,
-                SCP_CLARK_SCMI_SERVICE_IDX_PSCI),
+                SCP_RDN1E1_SCMI_SERVICE_IDX_PSCI),
             .transport_api_id = FWK_ID_API_INIT(
                 FWK_MODULE_IDX_SMT,
                 MOD_SMT_API_IDX_SCMI_TRANSPORT),
             .scmi_agent_id = SCP_SCMI_AGENT_ID_PSCI,
         }),
     },
-    [SCP_CLARK_SCMI_SERVICE_IDX_OSPM] = {
+    [SCP_RDN1E1_SCMI_SERVICE_IDX_OSPM] = {
         .name = "SERVICE1",
         .data = &((struct mod_scmi_service_config) {
             .transport_id = FWK_ID_ELEMENT_INIT(
                 FWK_MODULE_IDX_SMT,
-                SCP_CLARK_SCMI_SERVICE_IDX_OSPM),
+                SCP_RDN1E1_SCMI_SERVICE_IDX_OSPM),
             .transport_api_id = FWK_ID_API_INIT(
                 FWK_MODULE_IDX_SMT,
                 MOD_SMT_API_IDX_SCMI_TRANSPORT),
             .scmi_agent_id = SCP_SCMI_AGENT_ID_OSPM,
         }),
     },
-    [SCP_CLARK_SCMI_SERVICE_IDX_COUNT] = { 0 }
+    [SCP_RDN1E1_SCMI_SERVICE_IDX_COUNT] = { 0 }
 };
 
 static const struct fwk_element *get_service_table(fwk_id_t module_id)
diff --git a/product/clark/scp_ramfw/config_scmi_apcore.c b/product/rdn1e1/scp_ramfw/config_scmi_apcore.c
index 9c24de77..7f1ced71 100644
--- a/product/clark/scp_ramfw/config_scmi_apcore.c
+++ b/product/rdn1e1/scp_ramfw/config_scmi_apcore.c
@@ -5,8 +5,8 @@
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
-#include <clark_core.h>
-#include <scp_clark_pik.h>
+#include <rdn1e1_core.h>
+#include <scp_rdn1e1_pik.h>
 #include <mod_scmi_apcore.h>
 #include <fwk_element.h>
 #include <fwk_macros.h>
@@ -17,7 +17,7 @@ static const struct mod_scmi_apcore_reset_register_group
         {
             .base_register =
                 (uintptr_t)&PIK_CLUSTER(0)->STATIC_CONFIG[0].RVBARADDR_LW,
-            .register_count = CLARK_CORE_PER_CLUSTER_MAX,
+            .register_count = RDN1E1_CORE_PER_CLUSTER_MAX,
         },
     };
 
diff --git a/product/clark/scp_ramfw/config_scmi_perf.c b/product/rdn1e1/scp_ramfw/config_scmi_perf.c
index fa4d82a6..57b3baf2 100644
--- a/product/clark/scp_ramfw/config_scmi_perf.c
+++ b/product/rdn1e1/scp_ramfw/config_scmi_perf.c
@@ -8,7 +8,7 @@
 #include <stdint.h>
 #include <fwk_element.h>
 #include <fwk_module.h>
-#include <scp_clark_scmi.h>
+#include <scp_rdn1e1_scmi.h>
 #include <mod_scmi_perf.h>
 
 static const struct mod_scmi_perf_domain_config domains[] = {
diff --git a/product/clark/scp_ramfw/config_scmi_system_power.c b/product/rdn1e1/scp_ramfw/config_scmi_system_power.c
index a405c6f0..a405c6f0 100644
--- a/product/clark/scp_ramfw/config_scmi_system_power.c
+++ b/product/rdn1e1/scp_ramfw/config_scmi_system_power.c
diff --git a/product/clark/scp_ramfw/config_sds.c b/product/rdn1e1/scp_ramfw/config_sds.c
index debe60f2..3590fe99 100644
--- a/product/clark/scp_ramfw/config_sds.c
+++ b/product/rdn1e1/scp_ramfw/config_sds.c
@@ -13,17 +13,17 @@
 #include <fwk_module_idx.h>
 #include <mod_sds.h>
 #include <mod_sid.h>
-#include <clark_sds.h>
-#include <scp_clark_mmap.h>
-#include <scp_clark_pik.h>
+#include <rdn1e1_sds.h>
+#include <scp_rdn1e1_mmap.h>
+#include <scp_rdn1e1_pik.h>
 #include <scp_software_mmap.h>
 #include <scp_system_mmap.h>
 #include <config_clock.h>
 
 static const uint32_t version_packed = FWK_BUILD_VERSION;
-static const uint32_t feature_flags = (CLARK_SDS_FEATURE_FIRMWARE_MASK |
-                                       CLARK_SDS_FEATURE_DMC_MASK |
-                                       CLARK_SDS_FEATURE_MESSAGING_MASK);
+static const uint32_t feature_flags = (RDN1E1_SDS_FEATURE_FIRMWARE_MASK |
+                                       RDN1E1_SDS_FEATURE_DMC_MASK |
+                                       RDN1E1_SDS_FEATURE_MESSAGING_MASK);
 
 const struct mod_sds_config sds_module_config = {
     .region_base_address = SCP_SDS_MEM_BASE,
@@ -36,16 +36,16 @@ static struct fwk_element sds_element_table[] = {
     {
         .name = "CPU Info",
         .data = &((struct mod_sds_structure_desc) {
-            .id = CLARK_SDS_CPU_INFO,
-            .size = CLARK_SDS_CPU_INFO_SIZE,
+            .id = RDN1E1_SDS_CPU_INFO,
+            .size = RDN1E1_SDS_CPU_INFO_SIZE,
             .finalize = true,
         }),
     },
     {
         .name = "Firmware version",
         .data = &((struct mod_sds_structure_desc) {
-            .id = CLARK_SDS_FIRMWARE_VERSION,
-            .size = CLARK_SDS_FIRMWARE_VERSION_SIZE,
+            .id = RDN1E1_SDS_FIRMWARE_VERSION,
+            .size = RDN1E1_SDS_FIRMWARE_VERSION_SIZE,
             .payload = &version_packed,
             .finalize = true,
         }),
@@ -53,8 +53,8 @@ static struct fwk_element sds_element_table[] = {
     {
         .name = "Reset Syndrome",
         .data = &((struct mod_sds_structure_desc) {
-            .id = CLARK_SDS_RESET_SYNDROME,
-            .size = CLARK_SDS_RESET_SYNDROME_SIZE,
+            .id = RDN1E1_SDS_RESET_SYNDROME,
+            .size = RDN1E1_SDS_RESET_SYNDROME_SIZE,
             .payload = (void *)(&PIK_SCP->RESET_SYNDROME),
             .finalize = true,
         }),
@@ -62,8 +62,8 @@ static struct fwk_element sds_element_table[] = {
     {
         .name = "Feature Availability",
         .data = &((struct mod_sds_structure_desc) {
-            .id = CLARK_SDS_FEATURE_AVAILABILITY,
-            .size = CLARK_SDS_FEATURE_AVAILABILITY_SIZE,
+            .id = RDN1E1_SDS_FEATURE_AVAILABILITY,
+            .size = RDN1E1_SDS_FEATURE_AVAILABILITY_SIZE,
             .payload = &feature_flags,
             .finalize = true,
         }),
@@ -72,16 +72,16 @@ static struct fwk_element sds_element_table[] = {
     {
         .name = "Boot Counters",
         .data = &((struct mod_sds_structure_desc) {
-            .id = CLARK_SDS_CPU_BOOTCTR,
-            .size = CLARK_SDS_CPU_BOOTCTR_SIZE,
+            .id = RDN1E1_SDS_CPU_BOOTCTR,
+            .size = RDN1E1_SDS_CPU_BOOTCTR_SIZE,
             .finalize = true,
         }),
     },
     {
         .name = "CPU Flags",
         .data = &((struct mod_sds_structure_desc) {
-            .id = CLARK_SDS_CPU_FLAGS,
-            .size = CLARK_SDS_CPU_FLAGS_SIZE,
+            .id = RDN1E1_SDS_CPU_FLAGS,
+            .size = RDN1E1_SDS_CPU_FLAGS_SIZE,
             .finalize = true,
         }),
     },
diff --git a/product/clark/scp_ramfw/config_sensor.c b/product/rdn1e1/scp_ramfw/config_sensor.c
index 3a1a0719..3a1a0719 100644
--- a/product/clark/scp_ramfw/config_sensor.c
+++ b/product/rdn1e1/scp_ramfw/config_sensor.c
diff --git a/product/clark/scp_ramfw/config_smt.c b/product/rdn1e1/scp_ramfw/config_smt.c
index 9ea86a25..6ccb43a0 100644
--- a/product/clark/scp_ramfw/config_smt.c
+++ b/product/rdn1e1/scp_ramfw/config_smt.c
@@ -11,14 +11,14 @@
 #include <fwk_module.h>
 #include <fwk_module_idx.h>
 #include <mod_smt.h>
-#include <clark_core.h>
-#include <scp_clark_mhu.h>
-#include <scp_clark_scmi.h>
+#include <rdn1e1_core.h>
+#include <scp_rdn1e1_mhu.h>
+#include <scp_rdn1e1_scmi.h>
 #include <scp_software_mmap.h>
 #include <config_power_domain.h>
 
 static const struct fwk_element smt_element_table[] = {
-    [SCP_CLARK_SCMI_SERVICE_IDX_PSCI] = {
+    [SCP_RDN1E1_SCMI_SERVICE_IDX_PSCI] = {
         .name = "PSCI",
         .data = &((struct mod_smt_channel_config) {
             .type = MOD_SMT_CHANNEL_TYPE_SLAVE,
@@ -26,11 +26,11 @@ static const struct fwk_element smt_element_table[] = {
             .mailbox_address = (uintptr_t)SCP_SCMI_PAYLOAD_S_A2P_BASE,
             .mailbox_size = SCP_SCMI_PAYLOAD_SIZE,
             .driver_id = FWK_ID_SUB_ELEMENT_INIT(FWK_MODULE_IDX_MHU2,
-                SCP_CLARK_MHU_DEVICE_IDX_SCP_AP_S_CLUS0, 0),
+                SCP_RDN1E1_MHU_DEVICE_IDX_SCP_AP_S_CLUS0, 0),
             .driver_api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_MHU2, 0),
         })
     },
-    [SCP_CLARK_SCMI_SERVICE_IDX_OSPM] = {
+    [SCP_RDN1E1_SCMI_SERVICE_IDX_OSPM] = {
         .name = "OSPM",
         .data = &((struct mod_smt_channel_config) {
             .type = MOD_SMT_CHANNEL_TYPE_SLAVE,
@@ -38,11 +38,11 @@ static const struct fwk_element smt_element_table[] = {
             .mailbox_address = (uintptr_t)SCP_SCMI_PAYLOAD_NS_A2P_BASE,
             .mailbox_size = SCP_SCMI_PAYLOAD_SIZE,
             .driver_id = FWK_ID_SUB_ELEMENT_INIT(FWK_MODULE_IDX_MHU2,
-                 SCP_CLARK_MHU_DEVICE_IDX_SCP_AP_NS_CLUS0, 0),
+                 SCP_RDN1E1_MHU_DEVICE_IDX_SCP_AP_NS_CLUS0, 0),
             .driver_api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_MHU2, 0),
         })
     },
-    [SCP_CLARK_SCMI_SERVICE_IDX_COUNT] = { 0 },
+    [SCP_RDN1E1_SCMI_SERVICE_IDX_COUNT] = { 0 },
 };
 
 static const struct fwk_element *smt_get_element_table(fwk_id_t module_id)
@@ -50,10 +50,10 @@ static const struct fwk_element *smt_get_element_table(fwk_id_t module_id)
     unsigned int idx;
     struct mod_smt_channel_config *config;
 
-    for (idx = 0; idx < SCP_CLARK_SCMI_SERVICE_IDX_COUNT; idx++) {
+    for (idx = 0; idx < SCP_RDN1E1_SCMI_SERVICE_IDX_COUNT; idx++) {
         config = (struct mod_smt_channel_config *)(smt_element_table[idx].data);
         config->pd_source_id = FWK_ID_ELEMENT(FWK_MODULE_IDX_POWER_DOMAIN,
-            clark_core_get_core_count() + PD_STATIC_DEV_IDX_SYSTOP);
+            rdn1e1_core_get_core_count() + PD_STATIC_DEV_IDX_SYSTOP);
     }
 
     return smt_element_table;
diff --git a/product/clark/scp_ramfw/config_system_pll.c b/product/rdn1e1/scp_ramfw/config_system_pll.c
index fb0df7d4..2562196f 100644
--- a/product/clark/scp_ramfw/config_system_pll.c
+++ b/product/rdn1e1/scp_ramfw/config_system_pll.c
@@ -10,8 +10,8 @@
 #include <fwk_macros.h>
 #include <fwk_module.h>
 #include <mod_system_pll.h>
-#include <clark_pik_scp.h>
-#include <scp_clark_pik.h>
+#include <rdn1e1_pik_scp.h>
+#include <scp_rdn1e1_pik.h>
 #include <scp_system_mmap.h>
 #include <config_clock.h>
 
diff --git a/product/clark/scp_ramfw/config_system_power.c b/product/rdn1e1/scp_ramfw/config_system_power.c
index f8259885..c92d6549 100644
--- a/product/clark/scp_ramfw/config_system_power.c
+++ b/product/rdn1e1/scp_ramfw/config_system_power.c
@@ -9,14 +9,14 @@
 #include <fwk_macros.h>
 #include <fwk_module.h>
 #include <fwk_module_idx.h>
-#include <scp_clark_irq.h>
-#include <mod_clark_system.h>
+#include <scp_rdn1e1_irq.h>
+#include <mod_rdn1e1_system.h>
 #include <mod_system_power.h>
 #include <mod_ppu_v1.h>
-#include <clark_core.h>
+#include <rdn1e1_core.h>
 
 /* Table with only a terminator */
-static const struct fwk_element clark_system_element_table = { 0 };
+static const struct fwk_element rdn1e1_system_element_table = { 0 };
 
 static struct mod_system_power_config system_power_config = {
     .soc_wakeup_irq = SOC_WAKEUP0_IRQ,
@@ -27,17 +27,17 @@ static struct mod_system_power_config system_power_config = {
         MOD_PPU_V1_API_IDX_POWER_DOMAIN_DRIVER),
 
     /* System driver */
-    .driver_id = FWK_ID_MODULE_INIT(FWK_MODULE_IDX_CLARK_SYSTEM),
-    .driver_api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_CLARK_SYSTEM,
-         MOD_CLARK_SYSTEM_API_IDX_SYSTEM_POWER_DRIVER),
+    .driver_id = FWK_ID_MODULE_INIT(FWK_MODULE_IDX_RDN1E1_SYSTEM),
+    .driver_api_id = FWK_ID_API_INIT(FWK_MODULE_IDX_RDN1E1_SYSTEM,
+         MOD_RDN1E1_SYSTEM_API_IDX_SYSTEM_POWER_DRIVER),
 };
 
-static const struct fwk_element *clark_system_get_element_table(
+static const struct fwk_element *rdn1e1_system_get_element_table(
     fwk_id_t unused)
 {
     /* The system PPUs are placed after the core and cluster PPUs */
-    unsigned int ppu_idx_base = clark_core_get_core_count() +
-                                clark_core_get_cluster_count();
+    unsigned int ppu_idx_base = rdn1e1_core_get_core_count() +
+                                rdn1e1_core_get_cluster_count();
 
     /* Set the system PPU elements */
     system_power_config.ppu_sys0_id = fwk_id_build_element_id(
@@ -49,10 +49,10 @@ static const struct fwk_element *clark_system_get_element_table(
      * Return table with only a terminator as this function is only used to
      * setup the dynamic module data.
      */
-    return &clark_system_element_table;
+    return &rdn1e1_system_element_table;
 }
 
 const struct fwk_module_config config_system_power = {
-    .get_element_table = clark_system_get_element_table,
+    .get_element_table = rdn1e1_system_get_element_table,
     .data = &system_power_config,
 };
diff --git a/product/clark/scp_ramfw/config_timer.c b/product/rdn1e1/scp_ramfw/config_timer.c
index cd446642..cf25a45c 100644
--- a/product/clark/scp_ramfw/config_timer.c
+++ b/product/rdn1e1/scp_ramfw/config_timer.c
@@ -10,8 +10,8 @@
 #include <fwk_module_idx.h>
 #include <mod_gtimer.h>
 #include <mod_timer.h>
-#include <scp_clark_irq.h>
-#include <scp_clark_mmap.h>
+#include <scp_rdn1e1_irq.h>
+#include <scp_rdn1e1_mmap.h>
 #include <system_clock.h>
 #include <config_clock.h>
 
diff --git a/product/clark/scp_ramfw/firmware.mk b/product/rdn1e1/scp_ramfw/firmware.mk
index 25bc3109..1e0c1ae5 100644
--- a/product/clark/scp_ramfw/firmware.mk
+++ b/product/rdn1e1/scp_ramfw/firmware.mk
@@ -44,7 +44,7 @@ BS_FIRMWARE_MODULES := \
     psu \
     dvfs \
     scmi_perf \
-    clark_system
+    rdn1e1_system
 
 BS_FIRMWARE_SOURCES := \
     config_system_power.c \
diff --git a/product/clark/scp_ramfw/fmw_memory.ld.S b/product/rdn1e1/scp_ramfw/fmw_memory.ld.S
index c80bdd29..c80bdd29 100644
--- a/product/clark/scp_ramfw/fmw_memory.ld.S
+++ b/product/rdn1e1/scp_ramfw/fmw_memory.ld.S
diff --git a/product/clark/scp_ramfw/rtx_config.c b/product/rdn1e1/scp_ramfw/rtx_config.c
index 75f44c53..75f44c53 100644
--- a/product/clark/scp_ramfw/rtx_config.c
+++ b/product/rdn1e1/scp_ramfw/rtx_config.c
diff --git a/product/clark/scp_romfw/config_clock.c b/product/rdn1e1/scp_romfw/config_clock.c
index a01a1d37..a01a1d37 100644
--- a/product/clark/scp_romfw/config_clock.c
+++ b/product/rdn1e1/scp_romfw/config_clock.c
diff --git a/product/clark/scp_romfw/config_gtimer.c b/product/rdn1e1/scp_romfw/config_gtimer.c
index b14d57e3..c91b902d 100644
--- a/product/clark/scp_romfw/config_gtimer.c
+++ b/product/rdn1e1/scp_romfw/config_gtimer.c
@@ -8,7 +8,7 @@
 #include <fwk_id.h>
 #include <fwk_module.h>
 #include <mod_gtimer.h>
-#include <scp_clark_mmap.h>
+#include <scp_rdn1e1_mmap.h>
 #include <system_clock.h>
 
 /*
diff --git a/product/clark/scp_romfw/config_log.c b/product/rdn1e1/scp_romfw/config_log.c
index eb59739e..eb59739e 100644
--- a/product/clark/scp_romfw/config_log.c
+++ b/product/rdn1e1/scp_romfw/config_log.c
diff --git a/product/clark/scp_romfw/config_clark_rom.c b/product/rdn1e1/scp_romfw/config_rdn1e1_rom.c
index d8ad330c..13aa2f1d 100644
--- a/product/clark/scp_romfw/config_clark_rom.c
+++ b/product/rdn1e1/scp_romfw/config_rdn1e1_rom.c
@@ -6,12 +6,12 @@
  */
 
 #include <fwk_module.h>
-#include <mod_clark_rom.h>
+#include <mod_rdn1e1_rom.h>
 #include <scp_software_mmap.h>
-#include <scp_clark_mmap_scp.h>
+#include <scp_rdn1e1_mmap_scp.h>
 
-const struct fwk_module_config config_clark_rom = {
-    .data = &((struct clark_rom_config) {
+const struct fwk_module_config config_rdn1e1_rom = {
+    .data = &((struct rdn1e1_rom_config) {
         .ramfw_base = SCP_RAM0_BASE,
         .nor_base = SCP_NOR_BASE,
         .load_ram_size = SCP_IMAGE_SIZE,
diff --git a/product/clark/scp_romfw/firmware.mk b/product/rdn1e1/scp_romfw/firmware.mk
index 134f51a2..70155b5b 100644
--- a/product/clark/scp_romfw/firmware.mk
+++ b/product/rdn1e1/scp_romfw/firmware.mk
@@ -17,14 +17,14 @@ BS_FIRMWARE_MODULES := \
     pcid \
     pl011 \
     log \
-    clark_rom \
+    rdn1e1_rom \
     gtimer \
     clock
 
 BS_FIRMWARE_SOURCES := \
     config_sid.c \
     config_log.c \
-    config_clark_rom.c \
+    config_rdn1e1_rom.c \
     config_gtimer.c \
     config_clock.c
 
diff --git a/product/clark/scp_romfw/fmw_memory.ld.S b/product/rdn1e1/scp_romfw/fmw_memory.ld.S
index 6d3a33d3..6d3a33d3 100644
--- a/product/clark/scp_romfw/fmw_memory.ld.S
+++ b/product/rdn1e1/scp_romfw/fmw_memory.ld.S
diff --git a/product/clark/src/config_sid.c b/product/rdn1e1/src/config_sid.c
index f59d9c13..2e57223d 100644
--- a/product/clark/src/config_sid.c
+++ b/product/rdn1e1/src/config_sid.c
@@ -8,11 +8,11 @@
 #include <fwk_element.h>
 #include <fwk_module.h>
 #include <mod_sid.h>
-#include <scp_clark_mmap.h>
+#include <scp_rdn1e1_mmap.h>
 
 static const struct fwk_element subsystem_table[] = {
     {
-        .name = "Clark",
+        .name = "RDN1E1",
         .data = &(struct mod_sid_subsystem_config) {
             .part_number = 0x786,
         }
diff --git a/tools/ci.py b/tools/ci.py
index 3ff15f26..ef967f74 100755
--- a/tools/ci.py
+++ b/tools/ci.py
@@ -195,39 +195,39 @@ def main():
     result = subprocess.call(cmd, shell=True)
     results.append(('Product n1sdp release build (ARM)', result))
 
-    banner('Test building clark product')
+    banner('Test building rdn1e1 product')
 
     cmd = \
         'CC=arm-none-eabi-gcc ' \
-        'PRODUCT=clark ' \
+        'PRODUCT=rdn1e1 ' \
         'MODE=release ' \
         'make clean all'
     result = subprocess.call(cmd, shell=True)
-    results.append(('Product clark release build (GCC)', result))
+    results.append(('Product rdn1e1 release build (GCC)', result))
 
     cmd = \
         'CC=armclang ' \
-        'PRODUCT=clark ' \
+        'PRODUCT=rdn1e1 ' \
         'MODE=release ' \
         'make clean all'
     result = subprocess.call(cmd, shell=True)
-    results.append(('Product clark release build (ARM)', result))
+    results.append(('Product rdn1e1 release build (ARM)', result))
 
     cmd = \
         'CC=arm-none-eabi-gcc ' \
-        'PRODUCT=clark ' \
+        'PRODUCT=rdn1e1 ' \
         'MODE=debug ' \
         'make clean all'
     result = subprocess.call(cmd, shell=True)
-    results.append(('Product clark debug build (GCC)', result))
+    results.append(('Product rdn1e1 debug build (GCC)', result))
 
     cmd = \
         'CC=armclang ' \
-        'PRODUCT=clark ' \
+        'PRODUCT=rdn1e1 ' \
         'MODE=debug ' \
         'make clean all'
     result = subprocess.call(cmd, shell=True)
-    results.append(('Product clark debug build (ARM)', result))
+    results.append(('Product rdn1e1 debug build (ARM)', result))
 
     banner('Tests summary')