rdn1e1: Rename clark to rdn1e1

SGI-Clark has two configurations: one with Ares cores, and another with
Helios cores, which have been given the official product names
Neoverse N1 and E1 respectively.

This patch renames the clark product to better reflect these names,
becoming rdn1e1.

Change-Id: Ibdec9f03fdf4e76ee3ba2badb86e463a631f1938
Signed-off-by: Vijayenthiran Subramaniam <vijayenthiran.subramaniam@arm.com>

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')