diff --git a/arch/arc/core/reset.S b/arch/arc/core/reset.S
index 27b0f8c301a..bcb24a7cf58 100644
--- a/arch/arc/core/reset.S
+++ b/arch/arc/core/reset.S
@@ -90,7 +90,7 @@ done_cache_invalidate:
 
 #if defined(CONFIG_SYS_POWER_DEEP_SLEEP) && \
 	!defined(CONFIG_BOOTLOADER_CONTEXT_RESTORE)
-        jl @_sys_soc_resume_from_deep_sleep
+        jl @sys_soc_resume_from_deep_sleep
 #endif
 
 #ifdef CONFIG_INIT_STACKS
diff --git a/arch/x86/core/crt0.S b/arch/x86/core/crt0.S
index 4dbb57a32e8..4731da048a4 100644
--- a/arch/x86/core/crt0.S
+++ b/arch/x86/core/crt0.S
@@ -39,7 +39,7 @@
 #endif
 
 #ifdef CONFIG_SYS_POWER_DEEP_SLEEP
-	GTEXT(_sys_soc_resume_from_deep_sleep)
+	GTEXT(sys_soc_resume_from_deep_sleep)
 #endif
 
 #ifdef CONFIG_REALMODE
@@ -255,13 +255,13 @@ __csSet:
 	 * the ISR stack size are some multiple of STACK_ALIGN, which
 	 * is at least 4.
 	 *
-	 * This is also used to call the _sys_soc_resume_from_deep_sleep()
+	 * This is also used to call the sys_soc_resume_from_deep_sleep()
 	 * routine to avoid memory corruption if the system is resuming from
-	 * deep sleep. It is important that _sys_soc_resume_from_deep_sleep()
+	 * deep sleep. It is important that sys_soc_resume_from_deep_sleep()
 	 * restores the stack pointer to what it was at deep sleep before
          * enabling interrupts.  This is necessary to avoid
 	 * interfering with interrupt handler use of this stack.
-	 * If it is a cold boot then _sys_soc_resume_from_deep_sleep() should
+	 * If it is a cold boot then sys_soc_resume_from_deep_sleep() should
 	 * not do anything and must return immediately.
 	 */
 #ifdef CONFIG_INIT_STACKS
@@ -287,7 +287,7 @@ __csSet:
 #if defined(CONFIG_SYS_POWER_DEEP_SLEEP) && \
              !defined(CONFIG_BOOTLOADER_CONTEXT_RESTORE)
 	/*
-	 * Invoke _sys_soc_resume_from_deep_sleep() hook to handle resume from
+	 * Invoke sys_soc_resume_from_deep_sleep() hook to handle resume from
 	 * deep sleep. It should first check whether system is recovering from
 	 * deep sleep state. If it is, then this function should restore
 	 * states and resume at the point system went to deep sleep.
@@ -298,7 +298,7 @@ __csSet:
 	 * return and execution falls through to cold boot path.
 	 */
 
-	call _sys_soc_resume_from_deep_sleep
+	call sys_soc_resume_from_deep_sleep
 
 #endif
 
diff --git a/doc/subsystems/power_management.rst b/doc/subsystems/power_management.rst
index a92aa54021d..9d2f47208d8 100644
--- a/doc/subsystems/power_management.rst
+++ b/doc/subsystems/power_management.rst
@@ -103,10 +103,10 @@ Suspend Hook function
 
 .. code-block:: c
 
-   int _sys_soc_suspend(s32_t ticks);
+   int sys_soc_suspend(s32_t ticks);
 
 When the kernel is about to go idle, the power management subsystem calls the
-:code:`_sys_soc_suspend()` function, notifying the SOC interface that the kernel
+:code:`sys_soc_suspend()` function, notifying the SOC interface that the kernel
 is ready to enter the idle state.
 
 At this point, the kernel has disabled interrupts and computed the maximum
@@ -116,7 +116,7 @@ can be done in the available time. The power management operation must halt
 execution on a CPU or SOC low power state. Before entering the low power state,
 the SOC interface must setup a wake event.
 
-The power management subsystem expects the :code:`_sys_soc_suspend()` to
+The power management subsystem expects the :code:`sys_soc_suspend()` to
 return one of the following values based on the power management operations
 the SOC interface executed:
 
@@ -137,22 +137,22 @@ Resume Hook function
 
 .. code-block:: c
 
-   void _sys_soc_resume(void);
+   void sys_soc_resume(void);
 
 The power management subsystem optionally calls this hook function when exiting
 kernel idling if power management operations were performed in
-:code:`_sys_soc_suspend()`. Any necessary recovery operations can be performed
+:code:`sys_soc_suspend()`. Any necessary recovery operations can be performed
 in this function before the kernel scheduler schedules another thread. Some
 power states may not need this notification. It can be disabled by calling
-:code:`_sys_soc_pm_idle_exit_notification_disable()` from
-:code:`_sys_soc_suspend()`.
+:code:`sys_soc_pm_idle_exit_notification_disable()` from
+:code:`sys_soc_suspend()`.
 
 Resume From Deep Sleep Hook function
 ====================================
 
 .. code-block:: c
 
-   void _sys_soc_resume_from_deep_sleep(void);
+   void sys_soc_resume_from_deep_sleep(void);
 
 This function is optionally called when exiting from deep sleep if the SOC
 interface does not have bootloader support to handle resume from deep sleep.
@@ -231,7 +231,7 @@ in power saving mode. This method allows saving power even when the CPU is
 active. The components that use the devices need to be power aware and should
 be able to make decisions related to managing device power. In this method, the
 SOC interface can enter CPU or SOC low power states quickly when
-:code:`_sys_soc_suspend()` gets called. This is because it does not need to
+:code:`sys_soc_suspend()` gets called. This is because it does not need to
 spend time doing device power management if the devices are already put in
 the appropriate low power state by the application or component managing the
 devices.
@@ -240,7 +240,7 @@ Central method
 ==============
 
 In this method device power management is mostly done inside
-:code:`_sys_soc_suspend()` along with entering a CPU or SOC low power state.
+:code:`sys_soc_suspend()` along with entering a CPU or SOC low power state.
 
 If a decision to enter deep sleep is made, the implementation would enter it
 only after checking if the devices are not in the middle of a hardware
@@ -380,21 +380,21 @@ off, then such transactions would be left in an inconsistent state. This
 infrastructure guards such transactions by indicating to the SOC interface that
 the device is in the middle of a hardware transaction.
 
-When the :code:`_sys_soc_suspend()` is called, the SOC interface checks if any device
+When the :code:`sys_soc_suspend()` is called, the SOC interface checks if any device
 is busy. The SOC interface can then decide to execute a power management scheme other than deep sleep or
 to defer power management operations until the next call of
-:code:`_sys_soc_suspend()`.
+:code:`sys_soc_suspend()`.
 
 An alternative to using the busy status mechanism is to use the
 `distributed method`_ of device power management. In such a method where the
 device power management is handled in a distributed manner rather than centrally in
-:code:`_sys_soc_suspend()`, the decision to enter deep sleep can be made based
+:code:`sys_soc_suspend()`, the decision to enter deep sleep can be made based
 on whether all devices are already turned off.
 
 This feature can be also used to emulate a hardware feature found in some SOCs
 that causes the system to automatically enter deep sleep when all devices are idle.
 In such an usage, the busy status can be set by default and cleared as each
-device becomes idle. When :code:`_sys_soc_suspend()` is called, deep sleep can
+device becomes idle. When :code:`sys_soc_suspend()` is called, deep sleep can
 be entered if no device is found to be busy.
 
 Here are the APIs used to set, clear, and check the busy status of devices.
diff --git a/drivers/i2c/i2c_dw.c b/drivers/i2c/i2c_dw.c
index fec17c4fea5..e6c0b5fe3c1 100644
--- a/drivers/i2c/i2c_dw.c
+++ b/drivers/i2c/i2c_dw.c
@@ -433,7 +433,7 @@ static int i2c_dw_transfer(struct device *dev,
 
 	/*
 	 * While waiting at device_sync_sem, kernel can switch to idle
-	 * task which in turn can call _sys_soc_suspend() hook of Power
+	 * task which in turn can call sys_soc_suspend() hook of Power
 	 * Management App (PMA).
 	 * device_busy_set() call here, would indicate to PMA that it should not
 	 * execute PM policies that would turn off this ip block, causing an
diff --git a/include/power.h b/include/power.h
index 3614e68f01f..dc47807d1d5 100644
--- a/include/power.h
+++ b/include/power.h
@@ -20,7 +20,7 @@ extern "C" {
 
 #define SYS_PM_NOT_HANDLED		SYS_PM_ACTIVE_STATE
 
-extern unsigned char _sys_pm_idle_exit_notify;
+extern unsigned char sys_pm_idle_exit_notify;
 
 
 /**
@@ -40,15 +40,15 @@ extern unsigned char _sys_pm_idle_exit_notify;
 /**
  * @brief Function to disable power management idle exit notification
  *
- * _sys_soc_resume() would be called from the ISR of the event that caused
+ * sys_soc_resume() would be called from the ISR of the event that caused
  * exit from kernel idling after PM operations. For some power operations,
  * this notification may not be necessary. This function can be called in
- * _sys_soc_suspend to disable the corresponding _sys_soc_resume notification.
+ * sys_soc_suspend to disable the corresponding sys_soc_resume notification.
  *
  */
-static inline void _sys_soc_pm_idle_exit_notification_disable(void)
+static inline void sys_soc_pm_idle_exit_notification_disable(void)
 {
-	_sys_pm_idle_exit_notify = 0;
+	sys_pm_idle_exit_notify = 0;
 }
 
 /**
@@ -66,13 +66,13 @@ static inline void _sys_soc_pm_idle_exit_notification_disable(void)
  * function should return immediately.
  *
  */
-void _sys_soc_resume_from_deep_sleep(void);
+void sys_soc_resume_from_deep_sleep(void);
 
 /**
  * @brief Hook function to notify exit from kernel idling after PM operations
  *
  * This function would notify exit from kernel idling if a corresponding
- * _sys_soc_suspend() notification was handled and did not return
+ * sys_soc_suspend() notification was handled and did not return
  * SYS_PM_NOT_HANDLED.
  *
  * This function would be called from the ISR context of the event
@@ -84,11 +84,11 @@ void _sys_soc_resume_from_deep_sleep(void);
  * those cases, the ISR would be invoked immediately after the event wakes up
  * the CPU, before code following the CPU wait, gets a chance to execute. This
  * can be ignored if no operation needs to be done at the wake event
- * notification. Alternatively _sys_soc_pm_idle_exit_notification_disable() can
- * be called in _sys_soc_suspend to disable this notification.
+ * notification. Alternatively sys_soc_pm_idle_exit_notification_disable() can
+ * be called in sys_soc_suspend to disable this notification.
  *
  */
-void _sys_soc_resume(void);
+void sys_soc_resume(void);
 
 /**
  * @brief Hook function to allow entry to low power state
@@ -116,7 +116,7 @@ void _sys_soc_resume(void);
  * @retval SYS_PM_LOW_POWER_STATE If CPU low power state was entered.
  * @retval SYS_PM_DEEP_SLEEP If SOC low power state was entered.
  */
-extern int _sys_soc_suspend(s32_t ticks);
+extern int sys_soc_suspend(s32_t ticks);
 
 #ifdef CONFIG_PM_CONTROL_OS_DEBUG
 /**
diff --git a/kernel/idle.c b/kernel/idle.c
index aab4dbc2daa..e0357f96bbd 100644
--- a/kernel/idle.c
+++ b/kernel/idle.c
@@ -21,19 +21,19 @@
 
 #ifdef CONFIG_SYS_POWER_MANAGEMENT
 /*
- * Used to allow _sys_soc_suspend() implementation to control notification
+ * Used to allow sys_soc_suspend() implementation to control notification
  * of the event that caused exit from kernel idling after pm operations.
  */
-unsigned char _sys_pm_idle_exit_notify;
+unsigned char sys_pm_idle_exit_notify;
 
 #if defined(CONFIG_SYS_POWER_LOW_POWER_STATE)
-void __attribute__((weak)) _sys_soc_resume(void)
+void __attribute__((weak)) sys_soc_resume(void)
 {
 }
 #endif
 
 #if defined(CONFIG_SYS_POWER_DEEP_SLEEP)
-void __attribute__((weak)) _sys_soc_resume_from_deep_sleep(void)
+void __attribute__((weak)) sys_soc_resume_from_deep_sleep(void)
 {
 }
 #endif
@@ -77,7 +77,7 @@ static void sys_power_save_idle(void)
 #if (defined(CONFIG_SYS_POWER_LOW_POWER_STATE) || \
 	defined(CONFIG_SYS_POWER_DEEP_SLEEP))
 
-	_sys_pm_idle_exit_notify = 1U;
+	sys_pm_idle_exit_notify = 1U;
 
 	/*
 	 * Call the suspend hook function of the soc interface to allow
@@ -92,8 +92,8 @@ static void sys_power_save_idle(void)
 	 * idle processing re-enables interrupts which is essential for
 	 * the kernel's scheduling logic.
 	 */
-	if (_sys_soc_suspend(ticks) == SYS_PM_NOT_HANDLED) {
-		_sys_pm_idle_exit_notify = 0U;
+	if (sys_soc_suspend(ticks) == SYS_PM_NOT_HANDLED) {
+		sys_pm_idle_exit_notify = 0U;
 		k_cpu_idle();
 	}
 #else
@@ -108,11 +108,11 @@ void _sys_power_save_idle_exit(s32_t ticks)
 	/* Some CPU low power states require notification at the ISR
 	 * to allow any operations that needs to be done before kernel
 	 * switches task or processes nested interrupts. This can be
-	 * disabled by calling _sys_soc_pm_idle_exit_notification_disable().
+	 * disabled by calling sys_soc_pm_idle_exit_notification_disable().
 	 * Alternatively it can be simply ignored if not required.
 	 */
-	if (_sys_pm_idle_exit_notify) {
-		_sys_soc_resume();
+	if (sys_pm_idle_exit_notify) {
+		sys_soc_resume();
 	}
 #endif
 
diff --git a/samples/boards/nrf52/power_mgr/README.rst b/samples/boards/nrf52/power_mgr/README.rst
index a4ecfbdefe6..c5b6ddf2ad5 100644
--- a/samples/boards/nrf52/power_mgr/README.rst
+++ b/samples/boards/nrf52/power_mgr/README.rst
@@ -10,7 +10,7 @@ This sample demonstrates a power manager app that uses the Zephyr
 power management infrastructure to enter into Low Power state.
 
 This app will cycle through the following power schemes each time idle thread
-calls _sys_soc_suspend() hook function :
+calls sys_soc_suspend() hook function :
 
 1. Low Power State: Low Power State is SOC specific and being in this state is
    transparent to devices. SOC and devices do not lose context in this Mode.
diff --git a/samples/boards/nrf52/power_mgr/src/power.c b/samples/boards/nrf52/power_mgr/src/power.c
index 1b320b54497..52c517daa67 100644
--- a/samples/boards/nrf52/power_mgr/src/power.c
+++ b/samples/boards/nrf52/power_mgr/src/power.c
@@ -68,7 +68,7 @@ static int low_power_state_entry(void)
 	} else {
 		printk("--> Entering into Low Power State -");
 	}
-	_sys_soc_set_power_state(pm_state);
+	sys_soc_set_power_state(pm_state);
 	return SYS_PM_LOW_POWER_STATE;
 }
 
@@ -83,24 +83,24 @@ static int low_power_suspend_entry(void)
 {
 	printk("--> Entering into Deep Sleep State -");
 	/* Don't need pm idle exit event notification */
-	_sys_soc_pm_idle_exit_notification_disable();
+	sys_soc_pm_idle_exit_notification_disable();
 	/* Save device states and turn off peripherals as necessary */
 	suspend_devices();
-	_sys_soc_set_power_state(SYS_POWER_STATE_DEEP_SLEEP);
+	sys_soc_set_power_state(SYS_POWER_STATE_DEEP_SLEEP);
 	 /* Exiting from Deep Sleep State */
 	low_power_suspend_exit();
 
 	return SYS_PM_DEEP_SLEEP;
 }
 
-/* Function name : _sys_soc_suspend
+/* Function name : sys_soc_suspend
  * Return Value : Power Mode Entered Success/Failure
  * Input : Idleness in number of Ticks
  *
  * Description: All request from Idle thread to Enter into
  * Low Power Mode or Deep Sleep State land in this function
  */
-int _sys_soc_suspend(s32_t ticks)
+int sys_soc_suspend(s32_t ticks)
 {
 	int ret = SYS_PM_NOT_HANDLED;
 
@@ -142,14 +142,14 @@ int _sys_soc_suspend(s32_t ticks)
 				low_power_state_exit();
 			}
 			post_ops_done = 1;
-			_sys_soc_power_state_post_ops(pm_state);
+			sys_soc_power_state_post_ops(pm_state);
 		}
 	}
 
 	return ret;
 }
 
-void _sys_soc_resume(void)
+void sys_soc_resume(void)
 {
 	/*
 	 * This notification is called from the ISR of the event
@@ -163,7 +163,7 @@ void _sys_soc_resume(void)
 	 * The kernel scheduler will get control after the ISR finishes
 	 * and it may schedule another thread.
 	 *
-	 * Call _sys_soc_pm_idle_exit_notification_disable() if this
+	 * Call sys_soc_pm_idle_exit_notification_disable() if this
 	 * notification is not required.
 	 */
 	if (!post_ops_done) {
@@ -171,6 +171,6 @@ void _sys_soc_resume(void)
 			low_power_state_exit();
 		}
 		post_ops_done = 1;
-		_sys_soc_power_state_post_ops(pm_state);
+		sys_soc_power_state_post_ops(pm_state);
 	}
 }
diff --git a/samples/boards/quark_se_c1000/power_mgr/README.rst b/samples/boards/quark_se_c1000/power_mgr/README.rst
index cc9a1252808..33809907608 100644
--- a/samples/boards/quark_se_c1000/power_mgr/README.rst
+++ b/samples/boards/quark_se_c1000/power_mgr/README.rst
@@ -10,7 +10,7 @@ A sample implementation of a power manager app that uses the Zephyr
 power management infrastructure.
 
 This app will cycle through the various power schemes at every call
-to _sys_soc_suspend() hook function.
+to sys_soc_suspend() hook function.
 It will cycle through the following states:
 
 1. CPU Low Power State
diff --git a/samples/boards/quark_se_c1000/power_mgr/src/main.c b/samples/boards/quark_se_c1000/power_mgr/src/main.c
index e9b0450237e..d62fe4fe27e 100644
--- a/samples/boards/quark_se_c1000/power_mgr/src/main.c
+++ b/samples/boards/quark_se_c1000/power_mgr/src/main.c
@@ -143,7 +143,7 @@ static int low_power_state_entry(s32_t ticks)
 
 	enable_wake_event();
 
-	_sys_soc_set_power_state(SYS_POWER_STATE_CPU_LPS);
+	sys_soc_set_power_state(SYS_POWER_STATE_CPU_LPS);
 
 	return SYS_PM_LOW_POWER_STATE;
 }
@@ -155,14 +155,14 @@ static int deep_sleep_entry(s32_t ticks)
 	start_time = rtc_read(rtc_dev);
 
 	/* Don't need pm idle exit event notification */
-	_sys_soc_pm_idle_exit_notification_disable();
+	sys_soc_pm_idle_exit_notification_disable();
 
 	/* Save device states and turn off peripherals as necessary */
 	suspend_devices();
 
 	enable_wake_event();
 
-	_sys_soc_set_power_state(SYS_POWER_STATE_DEEP_SLEEP);
+	sys_soc_set_power_state(SYS_POWER_STATE_DEEP_SLEEP);
 
 	/*
 	 * At this point system has woken up from
@@ -174,7 +174,7 @@ static int deep_sleep_entry(s32_t ticks)
 	return SYS_PM_DEEP_SLEEP;
 }
 
-int _sys_soc_suspend(s32_t ticks)
+int sys_soc_suspend(s32_t ticks)
 {
 	int ret = SYS_PM_NOT_HANDLED;
 
@@ -220,7 +220,7 @@ int _sys_soc_suspend(s32_t ticks)
 		 * Some CPU power states would require interrupts to be
 		 * enabled at the time of entering the low power state.
 		 * For such states the post operations need to be done
-		 * at _sys_soc_resume. To avoid doing it twice, check a
+		 * at sys_soc_resume. To avoid doing it twice, check a
 		 * flag.
 		 */
 		if (!post_ops_done) {
@@ -228,14 +228,14 @@ int _sys_soc_suspend(s32_t ticks)
 				low_power_state_exit();
 			}
 			post_ops_done = 1;
-			_sys_soc_power_state_post_ops(pm_state);
+			sys_soc_power_state_post_ops(pm_state);
 		}
 	}
 
 	return ret;
 }
 
-void _sys_soc_resume(void)
+void sys_soc_resume(void)
 {
 	/*
 	 * This notification is called from the ISR of the event
@@ -249,7 +249,7 @@ void _sys_soc_resume(void)
 	 * The kernel scheduler will get control after the ISR finishes
 	 * and it may schedule another thread.
 	 *
-	 * Call _sys_soc_pm_idle_exit_notification_disable() if this
+	 * Call sys_soc_pm_idle_exit_notification_disable() if this
 	 * notification is not required.
 	 */
 	if (!post_ops_done) {
@@ -257,7 +257,7 @@ void _sys_soc_resume(void)
 			low_power_state_exit();
 		}
 		post_ops_done = 1;
-		_sys_soc_power_state_post_ops(pm_state);
+		sys_soc_power_state_post_ops(pm_state);
 	}
 }
 
diff --git a/samples/subsys/power/power_mgr/README.rst b/samples/subsys/power/power_mgr/README.rst
index 17e5bc64c93..2944f87319f 100644
--- a/samples/subsys/power/power_mgr/README.rst
+++ b/samples/subsys/power/power_mgr/README.rst
@@ -8,7 +8,7 @@ Overview
 
 This sample demonstrates OS managed power saving mechanism through the sample
 application which will periodically go sleep there by invoking the idle thread
-which will call the _sys_soc_suspend() to enter into low power states. The Low
+which will call the sys_soc_suspend() to enter into low power states. The Low
 Power state will be selected based on the next timeout event.
 
 Requirements
diff --git a/soc/arc/quark_se_c1000_ss/power.c b/soc/arc/quark_se_c1000_ss/power.c
index c98de6a4afc..7a6bc954054 100644
--- a/soc/arc/quark_se_c1000_ss/power.c
+++ b/soc/arc/quark_se_c1000_ss/power.c
@@ -39,7 +39,7 @@ static void _deep_sleep(enum power_states state)
 }
 #endif
 
-void _sys_soc_set_power_state(enum power_states state)
+void sys_soc_set_power_state(enum power_states state)
 {
 	switch (state) {
 	case SYS_POWER_STATE_CPU_LPS:
@@ -64,7 +64,7 @@ void _sys_soc_set_power_state(enum power_states state)
 	}
 }
 
-void _sys_soc_power_state_post_ops(enum power_states state)
+void sys_soc_power_state_post_ops(enum power_states state)
 {
 	u32_t limit;
 
diff --git a/soc/arc/quark_se_c1000_ss/soc_power.S b/soc/arc/quark_se_c1000_ss/soc_power.S
index cebed1351b9..4b616165c69 100644
--- a/soc/arc/quark_se_c1000_ss/soc_power.S
+++ b/soc/arc/quark_se_c1000_ss/soc_power.S
@@ -11,7 +11,7 @@
 #ifdef CONFIG_SYS_POWER_DEEP_SLEEP
 GDATA(_pm_arc_context)
 
-GTEXT(_sys_soc_resume_from_deep_sleep)
+GTEXT(sys_soc_resume_from_deep_sleep)
 GTEXT(_power_restore_cpu_context)
 GTEXT(_power_soc_sleep)
 GTEXT(_power_soc_deep_sleep)
@@ -24,7 +24,7 @@ GTEXT(_power_soc_lpss_mode)
 #define SLEEP_INTR_ENABLED_BIT 4
 #define SLEEP_MODE_RTC_ENABLED_BIT 5
 
-SECTION_FUNC(TEXT, _sys_soc_resume_from_deep_sleep)
+SECTION_FUNC(TEXT, sys_soc_resume_from_deep_sleep)
         /* Check is this wakeup after sleep event. */
         ld r0,[GPS0_REGISTER]
         bbit1 r0,RESTORE_SS_BIT,restore
@@ -37,7 +37,7 @@ restore:
 	/* Enable I-Cache */
         sr 1, [_ARC_V2_IC_CTRL]
 
-	j @_sys_soc_restore_cpu_context
+	j @sys_soc_restore_cpu_context
 
 SECTION_FUNC(TEXT, save_cpu_context)
 	mov_s r1, _kernel
@@ -114,7 +114,7 @@ SECTION_FUNC(TEXT, _power_soc_lpss_mode)
 	pop_s blink
 	j_s [blink]
 
-SECTION_FUNC(TEXT, _sys_soc_restore_cpu_context)
+SECTION_FUNC(TEXT, sys_soc_restore_cpu_context)
 	mov_s r1, _kernel
 	ld_s r2, [r1, _kernel_offset_to_current]
 
diff --git a/soc/arc/quark_se_c1000_ss/soc_power.h b/soc/arc/quark_se_c1000_ss/soc_power.h
index 1d400e585f2..98f81f0942a 100644
--- a/soc/arc/quark_se_c1000_ss/soc_power.h
+++ b/soc/arc/quark_se_c1000_ss/soc_power.h
@@ -65,7 +65,7 @@ enum power_states {
  * if the ARC wakes up and transitions again to
  * SYS_POWER_STATE_CPU_LPS. This is not required on the x86 side.
  */
-void _sys_soc_set_power_state(enum power_states state);
+void sys_soc_set_power_state(enum power_states state);
 
 /**
  * @brief Do any SoC or architecture specific post ops after low power states.
@@ -75,7 +75,7 @@ void _sys_soc_set_power_state(enum power_states state);
  * interrupts after resuming from deep sleep. In future, the enabling
  * of interrupts may be moved into the kernel.
  */
-void _sys_soc_power_state_post_ops(enum power_states state);
+void sys_soc_power_state_post_ops(enum power_states state);
 
 #ifdef __cplusplus
 }
diff --git a/soc/arm/nordic_nrf/nrf52/power.c b/soc/arm/nordic_nrf/nrf52/power.c
index 9ee8ac23984..9491fdb0140 100644
--- a/soc/arm/nordic_nrf/nrf52/power.c
+++ b/soc/arm/nordic_nrf/nrf52/power.c
@@ -57,7 +57,7 @@ static void _low_power_mode(enum power_states state)
 }
 
 /* Invoke Low Power/System Off specific Tasks */
-void _sys_soc_set_power_state(enum power_states state)
+void sys_soc_set_power_state(enum power_states state)
 {
 	switch (state) {
 	case SYS_POWER_STATE_CPU_LPS:
@@ -79,7 +79,7 @@ void _sys_soc_set_power_state(enum power_states state)
 }
 
 /* Handle SOC specific activity after Low Power Mode Exit */
-void _sys_soc_power_state_post_ops(enum power_states state)
+void sys_soc_power_state_post_ops(enum power_states state)
 {
 	switch (state) {
 	case SYS_POWER_STATE_CPU_LPS:
@@ -98,7 +98,7 @@ void _sys_soc_power_state_post_ops(enum power_states state)
 	}
 }
 
-bool _sys_soc_is_valid_power_state(enum power_states state)
+bool sys_soc_is_valid_power_state(enum power_states state)
 {
 	switch (state) {
 	case SYS_POWER_STATE_CPU_LPS:
diff --git a/soc/arm/nordic_nrf/nrf52/soc_power.h b/soc/arm/nordic_nrf/nrf52/soc_power.h
index c93c6bec274..d567f443294 100644
--- a/soc/arm/nordic_nrf/nrf52/soc_power.h
+++ b/soc/arm/nordic_nrf/nrf52/soc_power.h
@@ -27,17 +27,17 @@ enum power_states {
 /**
  * @brief Put processor into low power state
  */
-void _sys_soc_set_power_state(enum power_states state);
+void sys_soc_set_power_state(enum power_states state);
 
 /**
  * @brief Check a low power state is supported by SoC
  */
-bool _sys_soc_is_valid_power_state(enum power_states state);
+bool sys_soc_is_valid_power_state(enum power_states state);
 
 /**
  * @brief Do any SoC or architecture specific post ops after low power states.
  */
-void _sys_soc_power_state_post_ops(enum power_states state);
+void sys_soc_power_state_post_ops(enum power_states state);
 
 #ifdef __cplusplus
 }
diff --git a/soc/x86/intel_quark/quark_se/power.c b/soc/x86/intel_quark/quark_se/power.c
index 016d85f5233..5fa258bcba4 100644
--- a/soc/x86/intel_quark/quark_se/power.c
+++ b/soc/x86/intel_quark/quark_se/power.c
@@ -37,7 +37,7 @@ static void _deep_sleep(enum power_states state)
 	 * is restored. If necessary, it is possible to set the
 	 * resume vector to a location where additional processing
 	 * can be done before cpu context is restored and control
-	 * transferred to _sys_soc_suspend.
+	 * transferred to sys_soc_suspend.
 	 */
 	qm_x86_set_resume_vector(_power_restore_cpu_context,
 				 *__x86_restore_info);
@@ -57,7 +57,7 @@ static void _deep_sleep(enum power_states state)
 }
 #endif
 
-void _sys_soc_set_power_state(enum power_states state)
+void sys_soc_set_power_state(enum power_states state)
 {
 	switch (state) {
 	case SYS_POWER_STATE_CPU_LPS:
@@ -80,7 +80,7 @@ void _sys_soc_set_power_state(enum power_states state)
 	}
 }
 
-void _sys_soc_power_state_post_ops(enum power_states state)
+void sys_soc_power_state_post_ops(enum power_states state)
 {
 	switch (state) {
 	case SYS_POWER_STATE_CPU_LPS_2:
@@ -104,7 +104,7 @@ void _sys_soc_power_state_post_ops(enum power_states state)
 	}
 }
 
-bool _sys_soc_power_state_is_arc_ready(void)
+bool sys_soc_power_state_is_arc_ready(void)
 {
 	return QM_SCSS_GP->gp0 & GP0_BIT_SLEEP_READY ? true : false;
 }
diff --git a/soc/x86/intel_quark/quark_se/soc_power.S b/soc/x86/intel_quark/quark_se/soc_power.S
index 0ce64ab4651..147317badda 100644
--- a/soc/x86/intel_quark/quark_se/soc_power.S
+++ b/soc/x86/intel_quark/quark_se/soc_power.S
@@ -11,7 +11,7 @@ GDATA(_pm_save_gdtr)
 GDATA(_pm_save_idtr)
 GDATA(_pm_save_esp)
 
-GTEXT(_sys_soc_resume_from_deep_sleep)
+GTEXT(sys_soc_resume_from_deep_sleep)
 GTEXT(_power_restore_cpu_context)
 GTEXT(_power_soc_sleep)
 GTEXT(_power_soc_deep_sleep)
@@ -102,7 +102,7 @@ SECTION_FUNC(TEXT, _power_soc_deep_sleep)
  * Disclaimer: This can be used for debug or development purposes. This is not
  * a supported feature in Quark SE boards and to be used at one's own risk.
  */
-SECTION_FUNC(TEXT, _sys_soc_resume_from_deep_sleep)
+SECTION_FUNC(TEXT, sys_soc_resume_from_deep_sleep)
 	movl $CONFIG_BSP_SHARED_RESTORE_INFO_RAM_ADDR, %eax
 	cmpl $_power_restore_cpu_context, (%eax)
 	je _power_restore_cpu_context
diff --git a/soc/x86/intel_quark/quark_se/soc_power.h b/soc/x86/intel_quark/quark_se/soc_power.h
index de19414af70..aab9420bcc9 100644
--- a/soc/x86/intel_quark/quark_se/soc_power.h
+++ b/soc/x86/intel_quark/quark_se/soc_power.h
@@ -53,7 +53,7 @@ enum power_states {
  * SYS_POWER_STATE_DEEP_SLEEP_1: Only Always-On peripherals can wake up
  * the SoC. This consists of the Counter, RTC, GPIO 1 and AIO Comparator.
  */
-void _sys_soc_set_power_state(enum power_states state);
+void sys_soc_set_power_state(enum power_states state);
 
 /**
  * @brief Do any SoC or architecture specific post ops after low power states.
@@ -63,7 +63,7 @@ void _sys_soc_set_power_state(enum power_states state);
  * interrupts after resuming from deep sleep. In future, the enabling
  * of interrupts may be moved into the kernel.
  */
-void _sys_soc_power_state_post_ops(enum power_states state);
+void sys_soc_power_state_post_ops(enum power_states state);
 
 /**
  * @brief Check if ARC core is ready to enter in DEEP_SLEEP states.
@@ -71,7 +71,7 @@ void _sys_soc_power_state_post_ops(enum power_states state);
  * @retval true If ARC is ready.
  * @retval false Otherwise.
  */
-bool _sys_soc_power_state_is_arc_ready(void);
+bool sys_soc_power_state_is_arc_ready(void);
 
 #ifdef __cplusplus
 }
diff --git a/subsys/power/policy/policy_dummy.c b/subsys/power/policy/policy_dummy.c
index e8c06aaf3d4..8ed38c13e39 100644
--- a/subsys/power/policy/policy_dummy.c
+++ b/subsys/power/policy/policy_dummy.c
@@ -62,7 +62,7 @@ int sys_pm_policy_next_state(s32_t ticks, enum power_states *pm_state)
 		cur_pm_idx = 0;
 	}
 
-	if (!_sys_soc_is_valid_power_state(pm_policy[cur_pm_idx].pm_state)) {
+	if (!sys_soc_is_valid_power_state(pm_policy[cur_pm_idx].pm_state)) {
 		LOG_ERR("pm_state(%d) not supported by SoC\n",
 						pm_policy[cur_pm_idx].pm_state);
 		return SYS_PM_NOT_HANDLED;
diff --git a/subsys/power/policy/policy_residency.c b/subsys/power/policy/policy_residency.c
index 47a78043c7b..4ece68974a9 100644
--- a/subsys/power/policy/policy_residency.c
+++ b/subsys/power/policy/policy_residency.c
@@ -79,7 +79,7 @@ int sys_pm_policy_next_state(s32_t ticks, enum power_states *pm_state)
 		}
 	}
 
-	if (!_sys_soc_is_valid_power_state(pm_policy[i].pm_state)) {
+	if (!sys_soc_is_valid_power_state(pm_policy[i].pm_state)) {
 		LOG_ERR("pm_state(%d) not supported by SoC\n",
 						pm_policy[i].pm_state);
 		return SYS_PM_NOT_HANDLED;
diff --git a/subsys/power/power.c b/subsys/power/power.c
index 461e50d8aed..39adfe19c14 100644
--- a/subsys/power/power.c
+++ b/subsys/power/power.c
@@ -63,7 +63,7 @@ static void sys_pm_log_debug_info(enum power_states state) { }
 void sys_pm_dump_debug_info(void) { }
 #endif
 
-int _sys_soc_suspend(s32_t ticks)
+int sys_soc_suspend(s32_t ticks)
 {
 	int sys_state;
 
@@ -86,12 +86,12 @@ int _sys_soc_suspend(s32_t ticks)
 
 		/* Do CPU LPS operations */
 		sys_pm_debug_start_timer();
-		_sys_soc_set_power_state(pm_state);
+		sys_soc_set_power_state(pm_state);
 		sys_pm_debug_stop_timer();
 		break;
 	case SYS_PM_DEEP_SLEEP:
 		/* Don't need pm idle exit event notification */
-		_sys_soc_pm_idle_exit_notification_disable();
+		sys_soc_pm_idle_exit_notification_disable();
 
 		sys_pm_notify_lps_entry(pm_state);
 
@@ -103,7 +103,7 @@ int _sys_soc_suspend(s32_t ticks)
 
 		/* Enter CPU deep sleep state */
 		sys_pm_debug_start_timer();
-		_sys_soc_set_power_state(pm_state);
+		sys_soc_set_power_state(pm_state);
 		sys_pm_debug_stop_timer();
 
 		/* Turn on peripherals and restore device states as necessary */
@@ -125,14 +125,14 @@ int _sys_soc_suspend(s32_t ticks)
 		if (!post_ops_done) {
 			post_ops_done = 1;
 			sys_pm_notify_lps_exit(pm_state);
-			_sys_soc_power_state_post_ops(pm_state);
+			sys_soc_power_state_post_ops(pm_state);
 		}
 	}
 
 	return sys_state;
 }
 
-void _sys_soc_resume(void)
+void sys_soc_resume(void)
 {
 	/*
 	 * This notification is called from the ISR of the event
@@ -146,13 +146,13 @@ void _sys_soc_resume(void)
 	 * The kernel scheduler will get control after the ISR finishes
 	 * and it may schedule another thread.
 	 *
-	 * Call _sys_soc_pm_idle_exit_notification_disable() if this
+	 * Call sys_soc_pm_idle_exit_notification_disable() if this
 	 * notification is not required.
 	 */
 	if (!post_ops_done) {
 		post_ops_done = 1;
 		sys_pm_notify_lps_exit(pm_state);
-		_sys_soc_power_state_post_ops(pm_state);
+		sys_soc_power_state_post_ops(pm_state);
 	}
 }
 
diff --git a/tests/kernel/profiling/profiling_api/src/main.c b/tests/kernel/profiling/profiling_api/src/main.c
index 1355317b8e8..916671ce0eb 100644
--- a/tests/kernel/profiling/profiling_api/src/main.c
+++ b/tests/kernel/profiling/profiling_api/src/main.c
@@ -23,7 +23,7 @@ static void tdata_dump_callback(const struct k_thread *thread, void *user_data)
 }
 
 /*power hook functions*/
-int _sys_soc_suspend(s32_t ticks)
+int sys_soc_suspend(s32_t ticks)
 {
 	static bool test_flag;
 
@@ -38,7 +38,7 @@ int _sys_soc_suspend(s32_t ticks)
 	return 0;
 }
 
-void _sys_soc_resume(void)
+void sys_soc_resume(void)
 {
 }
 
@@ -81,7 +81,7 @@ void test_call_stacks_analyze_main(void)
  *
  * @ingroup kernel_profiling_tests
  *
- * @see k_thread_foreach(), _sys_soc_suspend(), _sys_soc_resume(),
+ * @see k_thread_foreach(), sys_soc_suspend(), sys_soc_resume(),
  * stack_analyze()
  */
 void test_call_stacks_analyze_idle(void)
diff --git a/tests/power/multicore/arc/src/main.c b/tests/power/multicore/arc/src/main.c
index b75e41bb262..779a3ddbbe7 100644
--- a/tests/power/multicore/arc/src/main.c
+++ b/tests/power/multicore/arc/src/main.c
@@ -42,28 +42,28 @@ static void resume_devices(void)
 	}
 }
 
-int _sys_soc_suspend(s32_t ticks)
+int sys_soc_suspend(s32_t ticks)
 {
 	post_ops_done = 0;
 
 	suspend_devices();
 
-	_sys_soc_set_power_state(SYS_POWER_STATE_DEEP_SLEEP);
+	sys_soc_set_power_state(SYS_POWER_STATE_DEEP_SLEEP);
 
 	if (!post_ops_done) {
 		post_ops_done = 1;
 		resume_devices();
-		_sys_soc_power_state_post_ops(SYS_POWER_STATE_DEEP_SLEEP);
+		sys_soc_power_state_post_ops(SYS_POWER_STATE_DEEP_SLEEP);
 	}
 
 	return SYS_PM_DEEP_SLEEP;
 }
 
-void _sys_soc_resume(void)
+void sys_soc_resume(void)
 {
 	if (!post_ops_done) {
 		post_ops_done = 1;
-		_sys_soc_power_state_post_ops(SYS_POWER_STATE_DEEP_SLEEP);
+		sys_soc_power_state_post_ops(SYS_POWER_STATE_DEEP_SLEEP);
 		resume_devices();
 	}
 }
diff --git a/tests/power/multicore/lmt/src/main.c b/tests/power/multicore/lmt/src/main.c
index 5d71001bddc..036b3ec88b0 100644
--- a/tests/power/multicore/lmt/src/main.c
+++ b/tests/power/multicore/lmt/src/main.c
@@ -49,25 +49,25 @@ static void resume_devices(void)
 	}
 }
 
-int _sys_soc_suspend(s32_t ticks)
+int sys_soc_suspend(s32_t ticks)
 {
 	printk("LMT: Try to put the system in SYS_POWER_STATE_DEEP_SLEEP_2"
 	       " state\n");
 
-	if (!_sys_soc_power_state_is_arc_ready()) {
+	if (!sys_soc_power_state_is_arc_ready()) {
 		printk("LMT: Failed. ARC is busy.\n");
 		return SYS_PM_NOT_HANDLED;
 	}
 
 	suspend_devices();
 
-	_sys_soc_set_power_state(SYS_POWER_STATE_CPU_LPS_2);
+	sys_soc_set_power_state(SYS_POWER_STATE_CPU_LPS_2);
 
 	resume_devices();
 
 	printk("LMT: Succeed.\n");
 
-	_sys_soc_power_state_post_ops(SYS_POWER_STATE_CPU_LPS_2);
+	sys_soc_power_state_post_ops(SYS_POWER_STATE_CPU_LPS_2);
 
 	return SYS_PM_DEEP_SLEEP;
 }
diff --git a/tests/power/power_states/src/main.c b/tests/power/power_states/src/main.c
index e0a67bee19b..24a837eaf7b 100644
--- a/tests/power/power_states/src/main.c
+++ b/tests/power/power_states/src/main.c
@@ -210,7 +210,7 @@ static void do_soc_sleep(enum power_states state)
 						DEVICE_PM_SUSPEND_STATE);
 	}
 
-	_sys_soc_set_power_state(state);
+	sys_soc_set_power_state(state);
 
 	/*
 	 * Before enabling the interrupts, check the wake source
@@ -242,7 +242,7 @@ static void do_soc_sleep(enum power_states state)
 	}
 }
 
-int _sys_soc_suspend(s32_t ticks)
+int sys_soc_suspend(s32_t ticks)
 {
 	enum power_states state;
 	int pm_operation = SYS_PM_NOT_HANDLED;
@@ -298,12 +298,12 @@ int _sys_soc_suspend(s32_t ticks)
 		 */
 		setup_wake_event();
 		pm_operation = SYS_PM_LOW_POWER_STATE;
-		_sys_soc_set_power_state(state);
+		sys_soc_set_power_state(state);
 		break;
 	case SYS_POWER_STATE_DEEP_SLEEP:
 	case SYS_POWER_STATE_DEEP_SLEEP_1:
 		/* Don't need pm idle exit notification */
-		_sys_soc_pm_idle_exit_notification_disable();
+		sys_soc_pm_idle_exit_notification_disable();
 
 		pm_operation = SYS_PM_DEEP_SLEEP;
 		do_soc_sleep(state);
@@ -317,14 +317,14 @@ int _sys_soc_suspend(s32_t ticks)
 		if (!post_ops_done) {
 			post_ops_done = 1;
 			printk("Exiting %s state\n", state_to_string(state));
-			_sys_soc_power_state_post_ops(state);
+			sys_soc_power_state_post_ops(state);
 		}
 	}
 
 	return pm_operation;
 }
 
-void _sys_soc_resume(void)
+void sys_soc_resume(void)
 {
 	enum power_states state = states_list[current_state];
 
@@ -337,12 +337,12 @@ void _sys_soc_resume(void)
 		if (!post_ops_done) {
 			post_ops_done = 1;
 			printk("Exiting %s state\n", state_to_string(state));
-			_sys_soc_power_state_post_ops(state);
+			sys_soc_power_state_post_ops(state);
 		}
 		break;
 	case SYS_POWER_STATE_DEEP_SLEEP:
 	case SYS_POWER_STATE_DEEP_SLEEP_1:
-		/* Do not perform post_ops in _sys_soc_resume for deep sleep.
+		/* Do not perform post_ops in sys_soc_resume for deep sleep.
 		 * This would make the application task run without the full
 		 * context restored.
 		 */