tree: rename atomic_* functions to deprecated_atomic_*

We will move to an API compatible with Zephyr's API.  See the bug for
complete rationale and plan.

BUG=b:169151160
BRANCH=none
TEST=buildall

Signed-off-by: Jack Rosenthal <jrosenth@chromium.org>
Change-Id: Id611f663446abf00b24298a669f2ae47fef7f632
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/2427507
Tested-by: Dawid Niedźwiecki <dn@semihalf.com>
Reviewed-by: Tom Hughes <tomhughes@chromium.org>
Reviewed-by: Jett Rink <jettrink@chromium.org>

56 files changed, 337 insertions, 245 deletions

diff --git a/baseboard/dedede/variant_ec_it8320.c b/baseboard/dedede/variant_ec_it8320.c
index 1838f81a9a..a3abea9d58 100644
--- a/baseboard/dedede/variant_ec_it8320.c
+++ b/baseboard/dedede/variant_ec_it8320.c
@@ -20,7 +20,7 @@
 
 static void pp3300_a_pgood_low(void)
 {
-	atomic_clear(&pp3300_a_pgood, 1);
+	deprecated_atomic_clear(&pp3300_a_pgood, 1);
 
 	/* Disable low interrupt while asserted */
 	vcmp_enable(VCMP_SNS_PP3300_LOW, 0);
@@ -37,7 +37,7 @@ static void pp3300_a_pgood_low(void)
 
 static void pp3300_a_pgood_high(void)
 {
-	atomic_or(&pp3300_a_pgood, 1);
+	deprecated_atomic_or(&pp3300_a_pgood, 1);
 
 	/* Disable high interrupt while asserted */
 	vcmp_enable(VCMP_SNS_PP3300_HIGH, 0);
diff --git a/baseboard/dedede/variant_ec_npcx796fc.c b/baseboard/dedede/variant_ec_npcx796fc.c
index bd896449db..23e38519f8 100644
--- a/baseboard/dedede/variant_ec_npcx796fc.c
+++ b/baseboard/dedede/variant_ec_npcx796fc.c
@@ -26,7 +26,7 @@
 
 void pp3300_a_pgood_high(void)
 {
-	atomic_or(&pp3300_a_pgood, 1);
+	deprecated_atomic_or(&pp3300_a_pgood, 1);
 
 	/* Disable this interrupt while it's asserted. */
 	npcx_adc_thresh_int_enable(NPCX_ADC_THRESH1, 0);
@@ -42,7 +42,7 @@ void pp3300_a_pgood_high(void)
 
 void pp3300_a_pgood_low(void)
 {
-	atomic_clear(&pp3300_a_pgood, 1);
+	deprecated_atomic_clear(&pp3300_a_pgood, 1);
 
 	/* Disable this interrupt while it's asserted. */
 	npcx_adc_thresh_int_enable(NPCX_ADC_THRESH2, 0);
diff --git a/baseboard/hatch/baseboard.c b/baseboard/hatch/baseboard.c
index 841f398b9b..790a164f54 100644
--- a/baseboard/hatch/baseboard.c
+++ b/baseboard/hatch/baseboard.c
@@ -343,9 +343,9 @@ void baseboard_mst_enable_control(enum mst_source src, int level)
 	static uint32_t mst_input_levels;
 
 	if (level)
-		atomic_or(&mst_input_levels, 1 << src);
+		deprecated_atomic_or(&mst_input_levels, 1 << src);
 	else
-		atomic_clear(&mst_input_levels, 1 << src);
+		deprecated_atomic_clear(&mst_input_levels, 1 << src);
 
 	gpio_set_level(GPIO_EN_MST, mst_input_levels ? 1 : 0);
 }
diff --git a/board/samus/power_sequence.c b/board/samus/power_sequence.c
index 5abfc5f39c..be2c9961cd 100644
--- a/board/samus/power_sequence.c
+++ b/board/samus/power_sequence.c
@@ -502,9 +502,9 @@ enum power_state power_handle_state(enum power_state state)
 void set_pp5000_in_g3(int mask, int enable)
 {
 	if (enable)
-		atomic_or(&pp5000_in_g3, mask);
+		deprecated_atomic_or(&pp5000_in_g3, mask);
 	else
-		atomic_clear(&pp5000_in_g3, mask);
+		deprecated_atomic_clear(&pp5000_in_g3, mask);
 
 	/* if we are in G3 now, then set the rail accordingly */
 	if (chipset_in_state(CHIPSET_STATE_HARD_OFF))
diff --git a/board/samus_pd/board.c b/board/samus_pd/board.c
index 6241c313bc..fb98304c80 100644
--- a/board/samus_pd/board.c
+++ b/board/samus_pd/board.c
@@ -491,8 +491,8 @@ void pd_send_host_event(int mask)
 	if (!mask)
 		return;
 
-	atomic_or(&(host_event_status_flags), mask);
-	atomic_or(&(pd_status_flags), PD_STATUS_HOST_EVENT);
+	deprecated_atomic_or(&(host_event_status_flags), mask);
+	deprecated_atomic_or(&(pd_status_flags), PD_STATUS_HOST_EVENT);
 	pd_send_ec_int();
 }
 
@@ -593,7 +593,7 @@ static enum ec_status ec_status_host_cmd(struct host_cmd_handler_args *args)
 	r->status = pd_status_flags;
 
 	/* Clear host event */
-	atomic_clear(&(pd_status_flags), PD_STATUS_HOST_EVENT);
+	deprecated_atomic_clear(&(pd_status_flags), PD_STATUS_HOST_EVENT);
 
 	args->response_size = sizeof(*r);
 
@@ -608,10 +608,10 @@ host_event_status_host_cmd(struct host_cmd_handler_args *args)
 	struct ec_response_host_event_status *r = args->response;
 
 	/* Clear host event bit to avoid sending more unnecessary events */
-	atomic_clear(&(pd_status_flags), PD_STATUS_HOST_EVENT);
+	deprecated_atomic_clear(&(pd_status_flags), PD_STATUS_HOST_EVENT);
 
 	/* Read and clear the host event status to return to AP */
-	r->status = atomic_read_clear(&(host_event_status_flags));
+	r->status = deprecated_atomic_read_clear(&(host_event_status_flags));
 
 	args->response_size = sizeof(*r);
 	return EC_RES_SUCCESS;
diff --git a/board/twinkie/sniffer.c b/board/twinkie/sniffer.c
index 615816f85c..f94028b572 100644
--- a/board/twinkie/sniffer.c
+++ b/board/twinkie/sniffer.c
@@ -316,9 +316,9 @@ void sniffer_task(void)
 						+ (EP_PACKET_HEADER_SIZE>>1))),
 					samples[d >> 4]+off,
 					EP_PAYLOAD_SIZE);
-			atomic_clear((uint32_t *)&free_usb, 1 << u);
+			deprecated_atomic_clear((uint32_t *)&free_usb, 1 << u);
 			u = !u;
-			atomic_clear(&filled_dma, 1 << d);
+			deprecated_atomic_clear(&filled_dma, 1 << d);
 		}
 		led_reset_record();
 
diff --git a/chip/ish/uart.c b/chip/ish/uart.c
index d958dc94c5..b0f21cdf5f 100644
--- a/chip/ish/uart.c
+++ b/chip/ish/uart.c
@@ -264,7 +264,7 @@ static int uart_client_init(enum UART_PORT id, uint32_t baud_rate_id, int flags)
 
 	uart_ctx[id].client_flags = flags;
 
-	atomic_and(&uart_ctx[id].uart_state, ~UART_STATE_CG);
+	deprecated_atomic_and(&uart_ctx[id].uart_state, ~UART_STATE_CG);
 	uart_hw_init(id);
 
 	return EC_SUCCESS;
diff --git a/chip/lm4/i2c.c b/chip/lm4/i2c.c
index 7cd06c430f..73f9ead8e1 100644
--- a/chip/lm4/i2c.c
+++ b/chip/lm4/i2c.c
@@ -202,9 +202,9 @@ int chip_i2c_xfer(const int port, const uint16_t slave_addr_flags,
 		i2c_unwedge(port);
 
 		/* Clock timeout or arbitration lost.  Reset port to clear. */
-		atomic_or(LM4_SYSTEM_SRI2C_ADDR, BIT(port));
+		deprecated_atomic_or(LM4_SYSTEM_SRI2C_ADDR, BIT(port));
 		clock_wait_cycles(3);
-		atomic_clear(LM4_SYSTEM_SRI2C_ADDR, BIT(port));
+		deprecated_atomic_clear(LM4_SYSTEM_SRI2C_ADDR, BIT(port));
 		clock_wait_cycles(3);
 
 		/* Restore settings */
diff --git a/chip/mt8192_scp/ipi.c b/chip/mt8192_scp/ipi.c
index 4081e47075..7d62411d41 100644
--- a/chip/mt8192_scp/ipi.c
+++ b/chip/mt8192_scp/ipi.c
@@ -30,13 +30,13 @@ static uint32_t disable_irq_count, saved_int_mask;
 
 void ipi_disable_irq(void)
 {
-	if (atomic_inc(&disable_irq_count, 1) == 0)
+	if (deprecated_atomic_inc(&disable_irq_count, 1) == 0)
 		saved_int_mask = read_clear_int_mask();
 }
 
 void ipi_enable_irq(void)
 {
-	if (atomic_dec(&disable_irq_count, 1) == 1)
+	if (deprecated_atomic_dec(&disable_irq_count, 1) == 1)
 		set_int_mask(saved_int_mask);
 }
 
diff --git a/chip/npcx/cec.c b/chip/npcx/cec.c
index b41e36e127..76fbf8279f 100644
--- a/chip/npcx/cec.c
+++ b/chip/npcx/cec.c
@@ -256,7 +256,7 @@ static uint32_t apb1_freq_div_10k;
 
 static void send_mkbp_event(uint32_t event)
 {
-	atomic_or(&cec_events, event);
+	deprecated_atomic_or(&cec_events, event);
 	mkbp_send_event(EC_MKBP_EVENT_CEC_EVENT);
 }
 
@@ -963,7 +963,7 @@ DECLARE_HOST_COMMAND(EC_CMD_CEC_GET, hc_cec_get, EC_VER_MASK(0));
 
 static int cec_get_next_event(uint8_t *out)
 {
-	uint32_t event_out = atomic_read_clear(&cec_events);
+	uint32_t event_out = deprecated_atomic_read_clear(&cec_events);
 
 	memcpy(out, &event_out, sizeof(event_out));
 
diff --git a/chip/stm32/pwm.c b/chip/stm32/pwm.c
index 50a06889ed..1a8f2050d0 100644
--- a/chip/stm32/pwm.c
+++ b/chip/stm32/pwm.c
@@ -99,7 +99,7 @@ static void pwm_configure(enum pwm_channel ch)
 	/* Enable auto-reload preload, start counting */
 	tim->cr1 |= BIT(7) | BIT(0);
 
-	atomic_or(&using_pwm, 1 << ch);
+	deprecated_atomic_or(&using_pwm, 1 << ch);
 
 	/* Prevent sleep */
 	disable_sleep(SLEEP_MASK_PWM);
@@ -125,7 +125,7 @@ static void pwm_disable(enum pwm_channel ch)
 	/* Allow sleep */
 	enable_sleep(SLEEP_MASK_PWM);
 
-	atomic_clear(&using_pwm, 1 << ch);
+	deprecated_atomic_clear(&using_pwm, 1 << ch);
 
 	/* Unless another PWM is active... Then prevent sleep */
 	if (using_pwm)
@@ -147,7 +147,7 @@ int pwm_get_enabled(enum pwm_channel ch)
 
 static void pwm_reconfigure(enum pwm_channel ch)
 {
-	atomic_clear(&using_pwm, 1 << ch);
+	deprecated_atomic_clear(&using_pwm, 1 << ch);
 	pwm_configure(ch);
 }
 
diff --git a/chip/stm32/usart_info_command.c b/chip/stm32/usart_info_command.c
index f6a76d99f3..16d5e5747e 100644
--- a/chip/stm32/usart_info_command.c
+++ b/chip/stm32/usart_info_command.c
@@ -24,8 +24,10 @@ static int command_usart_info(int argc, char **argv)
 			 "    dropped %d bytes\n"
 			 "    overran %d times\n",
 			 config->hw->index + 1,
-			 atomic_read_clear(&(config->state->rx_dropped)),
-			 atomic_read_clear(&(config->state->rx_overrun)));
+			 deprecated_atomic_read_clear(
+				 &(config->state->rx_dropped)),
+			 deprecated_atomic_read_clear(
+				 &(config->state->rx_overrun)));
 
 		if (config->rx->info)
 			config->rx->info(config);
diff --git a/chip/stm32/usart_rx_dma.c b/chip/stm32/usart_rx_dma.c
index 8665e304e7..1867c0a310 100644
--- a/chip/stm32/usart_rx_dma.c
+++ b/chip/stm32/usart_rx_dma.c
@@ -81,7 +81,7 @@ static void usart_rx_dma_interrupt_common(
 		/* (new_index == old_index): nothing to add to the queue. */
 	}
 
-	atomic_add(&config->state->rx_dropped, new_bytes - added);
+	deprecated_atomic_add(&config->state->rx_dropped, new_bytes - added);
 
 	if (dma_config->state->max_bytes < new_bytes)
 		dma_config->state->max_bytes = new_bytes;
@@ -115,5 +115,5 @@ void usart_rx_dma_info(struct usart_config const *config)
 		DOWNCAST(config->rx, struct usart_rx_dma const, usart_rx);
 
 	ccprintf("    DMA RX max_bytes %d\n",
-		 atomic_read_clear(&dma_config->state->max_bytes));
+		 deprecated_atomic_read_clear(&dma_config->state->max_bytes));
 }
diff --git a/chip/stm32/usart_rx_interrupt-stm32f4.c b/chip/stm32/usart_rx_interrupt-stm32f4.c
index bfbee469a6..44e711327d 100644
--- a/chip/stm32/usart_rx_interrupt-stm32f4.c
+++ b/chip/stm32/usart_rx_interrupt-stm32f4.c
@@ -33,7 +33,7 @@ static void usart_rx_interrupt_handler(struct usart_config const *config)
 		uint8_t byte = STM32_USART_RDR(base);
 
 		if (!queue_add_unit(config->producer.queue, &byte))
-			atomic_add(&config->state->rx_dropped, 1);
+			deprecated_atomic_add(&config->state->rx_dropped, 1);
 	}
 }
 
diff --git a/chip/stm32/usart_rx_interrupt-stm32l.c b/chip/stm32/usart_rx_interrupt-stm32l.c
index 061689edf1..c0cd03d8c9 100644
--- a/chip/stm32/usart_rx_interrupt-stm32l.c
+++ b/chip/stm32/usart_rx_interrupt-stm32l.c
@@ -39,14 +39,14 @@ static void usart_rx_interrupt_handler(struct usart_config const *config)
 		if (!(status & STM32_USART_SR_RXNE))
 			(void)STM32_USART_RDR(config->hw->base);
 
-		atomic_add(&config->state->rx_overrun, 1);
+		deprecated_atomic_add(&config->state->rx_overrun, 1);
 	}
 
 	if (status & STM32_USART_SR_RXNE) {
 		uint8_t byte = STM32_USART_RDR(base);
 
 		if (!queue_add_unit(config->producer.queue, &byte))
-			atomic_add(&config->state->rx_dropped, 1);
+			deprecated_atomic_add(&config->state->rx_dropped, 1);
 	}
 }
 
diff --git a/chip/stm32/usart_rx_interrupt.c b/chip/stm32/usart_rx_interrupt.c
index 007cc63467..3cbf1f49f4 100644
--- a/chip/stm32/usart_rx_interrupt.c
+++ b/chip/stm32/usart_rx_interrupt.c
@@ -30,7 +30,7 @@ static void usart_rx_interrupt_handler(struct usart_config const *config)
 		uint8_t byte = STM32_USART_RDR(base);
 
 		if (!queue_add_unit(config->producer.queue, &byte))
-			atomic_add(&config->state->rx_dropped, 1);
+			deprecated_atomic_add(&config->state->rx_dropped, 1);
 	}
 }
 
diff --git a/chip/stm32/usb.c b/chip/stm32/usb.c
index 7eb2363787..1711480d53 100644
--- a/chip/stm32/usb.c
+++ b/chip/stm32/usb.c
@@ -517,7 +517,7 @@ void usb_wake(void)
 	}
 
 	/* Only allow one caller at a time. */
-	if (!atomic_read_clear(&usb_wake_done))
+	if (!deprecated_atomic_read_clear(&usb_wake_done))
 		return;
 
 	CPRINTF("WAKE\n");
diff --git a/chip/stm32/usb_hid_keyboard.c b/chip/stm32/usb_hid_keyboard.c
index 7ca9aeb164..c206f9a9c5 100644
--- a/chip/stm32/usb_hid_keyboard.c
+++ b/chip/stm32/usb_hid_keyboard.c
@@ -335,7 +335,7 @@ static void write_keyboard_report(void)
 		return;
 	}
 
-	if (atomic_read_clear(&hid_ep_data_ready)) {
+	if (deprecated_atomic_read_clear(&hid_ep_data_ready)) {
 		/*
 		 * Endpoint is not busy, and interrupt handler did not just
 		 * send the buffer: enable TX.
diff --git a/common/button.c b/common/button.c
index 5e84256f91..1dcebae3bd 100644
--- a/common/button.c
+++ b/common/button.c
@@ -381,8 +381,8 @@ static void simulate_button_release_deferred(void)
 		/* Check state for button pressed */
 		if (sim_button_state & BIT(buttons[button_idx].type)) {
 			/* Set state of the button as released */
-			atomic_clear(&sim_button_state,
-					BIT(buttons[button_idx].type));
+			deprecated_atomic_clear(&sim_button_state,
+						BIT(buttons[button_idx].type));
 
 			button_interrupt_simulate(button_idx);
 		}
@@ -398,8 +398,8 @@ static void simulate_button(uint32_t button_mask, int press_ms)
 	for (button_idx = 0; button_idx < BUTTON_COUNT; button_idx++) {
 		if (button_mask & BIT(button_idx)) {
 			/* Set state of the button as pressed */
-			atomic_or(&sim_button_state,
-					BIT(buttons[button_idx].type));
+			deprecated_atomic_or(&sim_button_state,
+					     BIT(buttons[button_idx].type));
 
 			button_interrupt_simulate(button_idx);
 		}
diff --git a/common/charge_manager.c b/common/charge_manager.c
index ab3da5a17c..de88d3e437 100644
--- a/common/charge_manager.c
+++ b/common/charge_manager.c
@@ -1248,9 +1248,9 @@ void charge_manager_source_port(int port, int enable)
 	int p, rp;
 
 	if (enable)
-		atomic_or(&source_port_bitmap, 1 << port);
+		deprecated_atomic_or(&source_port_bitmap, 1 << port);
 	else
-		atomic_clear(&source_port_bitmap, 1 << port);
+		deprecated_atomic_clear(&source_port_bitmap, 1 << port);
 
 	/* No change, exit early. */
 	if (prev_bitmap == source_port_bitmap)
diff --git a/common/device_event.c b/common/device_event.c
index ab11c0826c..16d34b8729 100644
--- a/common/device_event.c
+++ b/common/device_event.c
@@ -27,7 +27,7 @@ uint32_t device_get_current_events(void)
 
 static uint32_t device_get_and_clear_events(void)
 {
-	return atomic_read_clear(&device_current_events);
+	return deprecated_atomic_read_clear(&device_current_events);
 }
 
 static uint32_t device_get_enabled_events(void)
@@ -43,7 +43,7 @@ void device_set_events(uint32_t mask)
 	if ((device_current_events & mask) != mask)
 		CPRINTS("device event set 0x%08x", mask);
 
-	atomic_or(&device_current_events, mask);
+	deprecated_atomic_or(&device_current_events, mask);
 
 	/* Signal host that a device event is pending */
 	host_set_single_event(EC_HOST_EVENT_DEVICE);
@@ -55,7 +55,7 @@ void device_clear_events(uint32_t mask)
 	if (device_current_events & mask)
 		CPRINTS("device event clear 0x%08x", mask);
 
-	atomic_clear(&device_current_events, mask);
+	deprecated_atomic_clear(&device_current_events, mask);
 }
 
 static void device_set_enabled_events(uint32_t mask)
diff --git a/common/dptf.c b/common/dptf.c
index acc04b123f..75bcdcad01 100644
--- a/common/dptf.c
+++ b/common/dptf.c
@@ -47,7 +47,7 @@ int dptf_query_next_sensor_event(void)
 
 	for (id = 0; id < TEMP_SENSOR_COUNT; id++)
 		if (dptf_seen & BIT(id)) {  /* atomic? */
-			atomic_clear(&dptf_seen, BIT(id));
+			deprecated_atomic_clear(&dptf_seen, BIT(id));
 			return id;
 		}
 
@@ -79,13 +79,13 @@ static int dptf_check_temp_threshold(int sensor_id, int temp)
 		if (cond_went_true(&dptf_threshold[sensor_id][i].over)) {
 			CPRINTS("DPTF over threshold [%d][%d",
 				sensor_id, i);
-			atomic_or(&dptf_seen, BIT(sensor_id));
+			deprecated_atomic_or(&dptf_seen, BIT(sensor_id));
 			tripped = 1;
 		}
 		if (cond_went_false(&dptf_threshold[sensor_id][i].over)) {
 			CPRINTS("DPTF under threshold [%d][%d",
 				sensor_id, i);
-			atomic_or(&dptf_seen, BIT(sensor_id));
+			deprecated_atomic_or(&dptf_seen, BIT(sensor_id));
 			tripped = 1;
 		}
 	}
@@ -109,7 +109,7 @@ void dptf_set_temp_threshold(int sensor_id, int temp, int idx, int enable)
 		if (dptf_threshold[sensor_id][idx].temp == -1)
 			cond_init(&dptf_threshold[sensor_id][idx].over, 0);
 		dptf_threshold[sensor_id][idx].temp = temp;
-		atomic_clear(&dptf_seen, BIT(sensor_id));
+		deprecated_atomic_clear(&dptf_seen, BIT(sensor_id));
 	} else {
 		dptf_threshold[sensor_id][idx].temp = -1;
 	}
diff --git a/common/fpsensor/fpsensor.c b/common/fpsensor/fpsensor.c
index 2965b52fe9..5611fd828d 100644
--- a/common/fpsensor/fpsensor.c
+++ b/common/fpsensor/fpsensor.c
@@ -64,7 +64,7 @@ void fps_event(enum gpio_signal signal)
 
 static void send_mkbp_event(uint32_t event)
 {
-	atomic_or(&fp_events, event);
+	deprecated_atomic_or(&fp_events, event);
 	mkbp_send_event(EC_MKBP_EVENT_FINGERPRINT);
 }
 
@@ -783,7 +783,7 @@ int command_fpenroll(int argc, char **argv)
 				       FP_MODE_ENROLL_IMAGE);
 		if (rc != EC_SUCCESS)
 			break;
-		event = atomic_read_clear(&fp_events);
+		event = deprecated_atomic_read_clear(&fp_events);
 		percent = EC_MKBP_FP_ENROLL_PROGRESS(event);
 		CPRINTS("Enroll capture: %s (%d%%)",
 			enroll_str[EC_MKBP_FP_ERRCODE(event) & 3], percent);
@@ -806,7 +806,7 @@ DECLARE_CONSOLE_COMMAND_FLAGS(fpenroll, command_fpenroll, NULL,
 int command_fpmatch(int argc, char **argv)
 {
 	enum ec_error_list rc = fp_console_action(FP_MODE_MATCH);
-	uint32_t event = atomic_read_clear(&fp_events);
+	uint32_t event = deprecated_atomic_read_clear(&fp_events);
 
 	if (rc == EC_SUCCESS && event & EC_MKBP_FP_MATCH) {
 		uint32_t errcode = EC_MKBP_FP_ERRCODE(event);
@@ -832,7 +832,7 @@ int command_fpclear(int argc, char **argv)
 	if (rc < 0)
 		CPRINTS("Failed to clear fingerprint context: %d", rc);
 
-	atomic_read_clear(&fp_events);
+	deprecated_atomic_read_clear(&fp_events);
 
 	return rc;
 }
diff --git a/common/fpsensor/fpsensor_state.c b/common/fpsensor/fpsensor_state.c
index ec4ddb4fd9..82fa4f23a1 100644
--- a/common/fpsensor/fpsensor_state.c
+++ b/common/fpsensor/fpsensor_state.c
@@ -100,7 +100,7 @@ void fp_reset_and_clear_context(void)
 
 int fp_get_next_event(uint8_t *out)
 {
-	uint32_t event_out = atomic_read_clear(&fp_events);
+	uint32_t event_out = deprecated_atomic_read_clear(&fp_events);
 
 	memcpy(out, &event_out, sizeof(event_out));
 
diff --git a/common/host_event_commands.c b/common/host_event_commands.c
index e8619c6a62..01e1d577cf 100644
--- a/common/host_event_commands.c
+++ b/common/host_event_commands.c
@@ -266,9 +266,9 @@ static void host_events_atomic_or(host_event_t *e, host_event_t m)
 {
 	uint32_t *ptr = (uint32_t *)e;
 
-	atomic_or(ptr, (uint32_t)m);
+	deprecated_atomic_or(ptr, (uint32_t)m);
 #ifdef CONFIG_HOST_EVENT64
-	atomic_or(ptr + 1, (uint32_t)(m >> 32));
+	deprecated_atomic_or(ptr + 1, (uint32_t)(m >> 32));
 #endif
 }
 
@@ -276,9 +276,9 @@ static void host_events_atomic_clear(host_event_t *e, host_event_t m)
 {
 	uint32_t *ptr = (uint32_t *)e;
 
-	atomic_clear(ptr, (uint32_t)m);
+	deprecated_atomic_clear(ptr, (uint32_t)m);
 #ifdef CONFIG_HOST_EVENT64
-	atomic_clear(ptr + 1, (uint32_t)(m >> 32));
+	deprecated_atomic_clear(ptr + 1, (uint32_t)(m >> 32));
 #endif
 }
 
diff --git a/common/keyboard_mkbp.c b/common/keyboard_mkbp.c
index 45cd50f4f5..9b41ef593e 100644
--- a/common/keyboard_mkbp.c
+++ b/common/keyboard_mkbp.c
@@ -153,7 +153,7 @@ static int fifo_remove(uint8_t *buffp)
 	}
 
 	fifo_start = (fifo_start + 1) % FIFO_DEPTH;
-	atomic_sub(&fifo_entries, 1);
+	deprecated_atomic_sub(&fifo_entries, 1);
 	mutex_unlock(&fifo_remove_mutex);
 
 	return EC_SUCCESS;
@@ -250,7 +250,7 @@ test_mockable int mkbp_fifo_add(uint8_t event_type, const uint8_t *buffp)
 	fifo[fifo_end].event_type = event_type;
 	memcpy(&fifo[fifo_end].data, buffp, size);
 	fifo_end = (fifo_end + 1) % FIFO_DEPTH;
-	atomic_add(&fifo_entries, 1);
+	deprecated_atomic_add(&fifo_entries, 1);
 
 	/*
 	 * If our event didn't generate an interrupt then the host is still
diff --git a/common/keyboard_scan.c b/common/keyboard_scan.c
index f964ad7509..7e68c28bee 100644
--- a/common/keyboard_scan.c
+++ b/common/keyboard_scan.c
@@ -143,9 +143,10 @@ void keyboard_scan_enable(int enable, enum kb_scan_disable_masks mask)
 {
 	/* Access atomically */
 	if (enable) {
-		atomic_clear((uint32_t *)&disable_scanning_mask, mask);
+		deprecated_atomic_clear((uint32_t *)&disable_scanning_mask,
+					mask);
 	} else {
-		atomic_or((uint32_t *)&disable_scanning_mask, mask);
+		deprecated_atomic_or((uint32_t *)&disable_scanning_mask, mask);
 		clear_typematic_key();
 	}
 
diff --git a/common/motion_sense.c b/common/motion_sense.c
index c1bf6b8930..e739bc8f75 100644
--- a/common/motion_sense.c
+++ b/common/motion_sense.c
@@ -677,11 +677,12 @@ static int motion_sense_process(struct motion_sensor_t *sensor,
 
 	if (*event & TASK_EVENT_MOTION_ODR_CHANGE) {
 		const int sensor_bit = 1 << sensor_num;
-		int odr_pending = atomic_read_clear(&odr_event_required);
+		int odr_pending =
+			deprecated_atomic_read_clear(&odr_event_required);
 
 		is_odr_pending = odr_pending & sensor_bit;
 		odr_pending &= ~sensor_bit;
-		atomic_or(&odr_event_required, odr_pending);
+		deprecated_atomic_or(&odr_event_required, odr_pending);
 	}
 
 #ifdef CONFIG_ACCEL_INTERRUPTS
@@ -707,7 +708,8 @@ static int motion_sense_process(struct motion_sensor_t *sensor,
 	}
 	if (IS_ENABLED(CONFIG_ACCEL_FIFO) &&
 	    *event & TASK_EVENT_MOTION_FLUSH_PENDING) {
-		int flush_pending = atomic_read_clear(&sensor->flush_pending);
+		int flush_pending =
+			deprecated_atomic_read_clear(&sensor->flush_pending);
 
 		for (; flush_pending > 0; flush_pending--) {
 			motion_sense_fifo_insert_async_event(
@@ -1170,8 +1172,8 @@ static enum ec_status host_cmd_motion_sense(struct host_cmd_handler_args *args)
 			 * The new ODR may suspend sensor, leaving samples
 			 * in the FIFO. Flush it explicitly.
 			 */
-			atomic_or(&odr_event_required,
-				1 << (sensor - motion_sensors));
+			deprecated_atomic_or(&odr_event_required,
+					     1 << (sensor - motion_sensors));
 			task_set_event(TASK_ID_MOTIONSENSE,
 					TASK_EVENT_MOTION_ODR_CHANGE, 0);
 		}
@@ -1292,7 +1294,7 @@ static enum ec_status host_cmd_motion_sense(struct host_cmd_handler_args *args)
 		if (sensor == NULL)
 			return EC_RES_INVALID_PARAM;
 
-		atomic_add(&sensor->flush_pending, 1);
+		deprecated_atomic_add(&sensor->flush_pending, 1);
 
 		task_set_event(TASK_ID_MOTIONSENSE,
 			       TASK_EVENT_MOTION_FLUSH_PENDING, 0);
@@ -1645,8 +1647,8 @@ static int command_accel_data_rate(int argc, char **argv)
 		sensor->config[config_id].odr =
 			data | (round ? ROUND_UP_FLAG : 0);
 
-		atomic_or(&odr_event_required,
-			  1 << (sensor - motion_sensors));
+		deprecated_atomic_or(&odr_event_required,
+				     1 << (sensor - motion_sensors));
 		task_set_event(TASK_ID_MOTIONSENSE,
 				TASK_EVENT_MOTION_ODR_CHANGE, 0);
 	} else {
diff --git a/common/timer.c b/common/timer.c
index 9a149f93e6..b4c31360b6 100644
--- a/common/timer.c
+++ b/common/timer.c
@@ -33,7 +33,7 @@ static int timer_irq;
 static void expire_timer(task_id_t tskid)
 {
 	/* we are done with this timer */
-	atomic_clear(&timer_running, 1 << tskid);
+	deprecated_atomic_clear(&timer_running, 1 << tskid);
 	/* wake up the taks waiting for this timer */
 	task_set_event(tskid, TASK_EVENT_TIMER, 0);
 }
@@ -124,7 +124,7 @@ int timer_arm(timestamp_t event, task_id_t tskid)
 		return EC_ERROR_BUSY;
 
 	timer_deadline[tskid] = event;
-	atomic_or(&timer_running, BIT(tskid));
+	deprecated_atomic_or(&timer_running, BIT(tskid));
 
 	/* Modify the next event if needed */
 	if ((event.le.hi < now.le.hi) ||
@@ -138,7 +138,7 @@ void timer_cancel(task_id_t tskid)
 {
 	ASSERT(tskid < TASK_ID_COUNT);
 
-	atomic_clear(&timer_running, BIT(tskid));
+	deprecated_atomic_clear(&timer_running, BIT(tskid));
 	/*
 	 * Don't need to cancel the hardware timer interrupt, instead do
 	 * timer-related housekeeping when the next timer interrupt fires.
@@ -170,8 +170,8 @@ void usleep(unsigned us)
 
 	/* Re-queue other events which happened in the meanwhile */
 	if (evt)
-		atomic_or(task_get_event_bitmap(task_get_current()),
-			  evt & ~TASK_EVENT_TIMER);
+		deprecated_atomic_or(task_get_event_bitmap(task_get_current()),
+				     evt & ~TASK_EVENT_TIMER);
 }
 
 timestamp_t get_time(void)
diff --git a/common/usb_common.c b/common/usb_common.c
index a64999aad9..47b0bc9454 100644
--- a/common/usb_common.c
+++ b/common/usb_common.c
@@ -468,7 +468,7 @@ static uint32_t port_oc_reset_req;
 
 static void re_enable_ports(void)
 {
-	uint32_t ports = atomic_read_clear(&port_oc_reset_req);
+	uint32_t ports = deprecated_atomic_read_clear(&port_oc_reset_req);
 
 	while (ports) {
 		int port = __fls(ports);
@@ -510,7 +510,7 @@ void pd_handle_overcurrent(int port)
 	board_overcurrent_event(port, 1);
 
 	/* Wait 1s before trying to re-enable the port. */
-	atomic_or(&port_oc_reset_req, BIT(port));
+	deprecated_atomic_or(&port_oc_reset_req, BIT(port));
 	hook_call_deferred(&re_enable_ports_data, SECOND);
 }
 
@@ -743,7 +743,8 @@ static uint32_t pd_ports_to_resume;
 static void resume_pd_port(void)
 {
 	uint32_t port;
-	uint32_t suspended_ports = atomic_read_clear(&pd_ports_to_resume);
+	uint32_t suspended_ports =
+		deprecated_atomic_read_clear(&pd_ports_to_resume);
 
 	while (suspended_ports) {
 		port = __builtin_ctz(suspended_ports);
@@ -755,7 +756,7 @@ DECLARE_DEFERRED(resume_pd_port);
 
 void pd_deferred_resume(int port)
 {
-	atomic_or(&pd_ports_to_resume, 1 << port);
+	deprecated_atomic_or(&pd_ports_to_resume, 1 << port);
 	hook_call_deferred(&resume_pd_port_data, 5 * SECOND);
 }
 #endif /* CONFIG_USB_PD_TCPM_TCPCI */
diff --git a/common/usb_pd_host_cmd.c b/common/usb_pd_host_cmd.c
index 19e74b47aa..8bdc50a0e3 100644
--- a/common/usb_pd_host_cmd.c
+++ b/common/usb_pd_host_cmd.c
@@ -608,7 +608,7 @@ DECLARE_HOST_COMMAND(EC_CMD_PD_CONTROL, pd_control, EC_VER_MASK(0));
 /*
  * PD host event status for host command
  * Note: this variable must be aligned on 4-byte boundary because we pass the
- * address to atomic_ functions which use assembly to access them.
+ * address to deprecated_atomic_ functions which use assembly to access them.
  */
 static uint32_t pd_host_event_status __aligned(4);
 
@@ -618,7 +618,7 @@ hc_pd_host_event_status(struct host_cmd_handler_args *args)
 	struct ec_response_host_event_status *r = args->response;
 
 	/* Read and clear the host event status to return to AP */
-	r->status = atomic_read_clear(&pd_host_event_status);
+	r->status = deprecated_atomic_read_clear(&pd_host_event_status);
 
 	args->response_size = sizeof(*r);
 	return EC_RES_SUCCESS;
@@ -633,7 +633,7 @@ void pd_send_host_event(int mask)
 	if (!mask)
 		return;
 
-	atomic_or(&pd_host_event_status, mask);
+	deprecated_atomic_or(&pd_host_event_status, mask);
 	/* interrupt the AP */
 	host_set_single_event(EC_HOST_EVENT_PD_MCU);
 }
diff --git a/common/usb_pd_protocol.c b/common/usb_pd_protocol.c
index 83d16720d1..cbf1a193cb 100644
--- a/common/usb_pd_protocol.c
+++ b/common/usb_pd_protocol.c
@@ -531,10 +531,11 @@ static int reset_device_and_notify(int port)
 	 * waking the TCPC, but it has also set PD_EVENT_TCPC_RESET again, which
 	 * would result in a second, unnecessary init.
 	 */
-	atomic_clear(task_get_event_bitmap(task_get_current()),
-		     PD_EVENT_TCPC_RESET);
+	deprecated_atomic_clear(task_get_event_bitmap(task_get_current()),
+				PD_EVENT_TCPC_RESET);
 
-	waiting_tasks = atomic_read_clear(&pd[port].tasks_waiting_on_reset);
+	waiting_tasks =
+		deprecated_atomic_read_clear(&pd[port].tasks_waiting_on_reset);
 
 	/*
 	 * Now that we are done waking up the device, handle device access
@@ -562,8 +563,8 @@ static void pd_wait_for_wakeup(int port)
 		reset_device_and_notify(port);
 	} else {
 		/* Otherwise, we need to wait for the TCPC reset to complete */
-		atomic_or(&pd[port].tasks_waiting_on_reset,
-			  1 << task_get_current());
+		deprecated_atomic_or(&pd[port].tasks_waiting_on_reset,
+				     1 << task_get_current());
 		/*
 		 * NOTE: We could be sending the PD task the reset event while
 		 * it is already processing the reset event. If that occurs,
@@ -607,9 +608,11 @@ void pd_prevent_low_power_mode(int port, int prevent)
 	const int current_task_mask = (1 << task_get_current());
 
 	if (prevent)
-		atomic_or(&pd[port].tasks_preventing_lpm, current_task_mask);
+		deprecated_atomic_or(&pd[port].tasks_preventing_lpm,
+				     current_task_mask);
 	else
-		atomic_clear(&pd[port].tasks_preventing_lpm, current_task_mask);
+		deprecated_atomic_clear(&pd[port].tasks_preventing_lpm,
+					current_task_mask);
 }
 
 /* This is only called from the PD tasks that owns the port. */
diff --git a/common/usbc/usb_pe_drp_sm.c b/common/usbc/usb_pe_drp_sm.c
index bc21fb466c..45074126f3 100644
--- a/common/usbc/usb_pe_drp_sm.c
+++ b/common/usbc/usb_pe_drp_sm.c
@@ -64,17 +64,19 @@
 #define CPRINTS_L3(format, args...) CPRINTS_LX(3, format, ## args)
 
 
-#define PE_SET_FLAG(port, flag) atomic_or(&pe[port].flags, (flag))
-#define PE_CLR_FLAG(port, flag) atomic_clear(&pe[port].flags, (flag))
+#define PE_SET_FLAG(port, flag) deprecated_atomic_or(&pe[port].flags, (flag))
+#define PE_CLR_FLAG(port, flag) deprecated_atomic_clear(&pe[port].flags, (flag))
 #define PE_CHK_FLAG(port, flag) (pe[port].flags & (flag))
 
 /*
  * These macros SET, CLEAR, and CHECK, a DPM (Device Policy Manager)
  * Request. The Requests are listed in usb_pe_sm.h.
  */
-#define PE_SET_DPM_REQUEST(port, req) atomic_or(&pe[port].dpm_request,    (req))
-#define PE_CLR_DPM_REQUEST(port, req) atomic_clear(&pe[port].dpm_request, (req))
-#define PE_CHK_DPM_REQUEST(port, req) (pe[port].dpm_request &             (req))
+#define PE_SET_DPM_REQUEST(port, req) \
+	deprecated_atomic_or(&pe[port].dpm_request, (req))
+#define PE_CLR_DPM_REQUEST(port, req) \
+	deprecated_atomic_clear(&pe[port].dpm_request, (req))
+#define PE_CHK_DPM_REQUEST(port, req) (pe[port].dpm_request & (req))
 
 /*
  * Policy Engine Layer Flags
@@ -6078,9 +6080,10 @@ void pd_dfp_discovery_init(int port)
 	PE_CLR_FLAG(port, PE_FLAGS_VDM_SETUP_DONE |
 			  PE_FLAGS_MODAL_OPERATION);
 
-	atomic_or(&task_access[port][TCPC_TX_SOP], BIT(task_get_current()));
-	atomic_or(&task_access[port][TCPC_TX_SOP_PRIME],
-						   BIT(task_get_current()));
+	deprecated_atomic_or(&task_access[port][TCPC_TX_SOP],
+			     BIT(task_get_current()));
+	deprecated_atomic_or(&task_access[port][TCPC_TX_SOP_PRIME],
+			     BIT(task_get_current()));
 
 	memset(pe[port].discovery, 0, sizeof(pe[port].discovery));
 	memset(pe[port].partner_amodes, 0, sizeof(pe[port].partner_amodes));
@@ -6100,7 +6103,7 @@ void pd_dfp_discovery_init(int port)
 
 void pd_discovery_access_clear(int port, enum tcpm_transmit_type type)
 {
-	atomic_clear(&task_access[port][type], 0xFFFFFFFF);
+	deprecated_atomic_clear(&task_access[port][type], 0xFFFFFFFF);
 }
 
 bool pd_discovery_access_validate(int port, enum tcpm_transmit_type type)
@@ -6112,7 +6115,7 @@ struct pd_discovery *pd_get_am_discovery(int port, enum tcpm_transmit_type type)
 {
 	ASSERT(type < DISCOVERY_TYPE_COUNT);
 
-	atomic_or(&task_access[port][type], BIT(task_get_current()));
+	deprecated_atomic_or(&task_access[port][type], BIT(task_get_current()));
 	return &pe[port].discovery[type];
 }
 
diff --git a/common/usbc/usb_prl_sm.c b/common/usbc/usb_prl_sm.c
index 0cee9da45d..dd8a06c0bd 100644
--- a/common/usbc/usb_prl_sm.c
+++ b/common/usbc/usb_prl_sm.c
@@ -40,24 +40,32 @@
 #define CPRINTS(format, args...)
 #endif
 
-#define RCH_SET_FLAG(port, flag) atomic_or(&rch[port].flags, (flag))
-#define RCH_CLR_FLAG(port, flag) atomic_clear(&rch[port].flags, (flag))
+#define RCH_SET_FLAG(port, flag) deprecated_atomic_or(&rch[port].flags, (flag))
+#define RCH_CLR_FLAG(port, flag) \
+	deprecated_atomic_clear(&rch[port].flags, (flag))
 #define RCH_CHK_FLAG(port, flag) (rch[port].flags & (flag))
 
-#define TCH_SET_FLAG(port, flag) atomic_or(&tch[port].flags, (flag))
-#define TCH_CLR_FLAG(port, flag) atomic_clear(&tch[port].flags, (flag))
+#define TCH_SET_FLAG(port, flag) deprecated_atomic_or(&tch[port].flags, (flag))
+#define TCH_CLR_FLAG(port, flag) \
+	deprecated_atomic_clear(&tch[port].flags, (flag))
 #define TCH_CHK_FLAG(port, flag) (tch[port].flags & (flag))
 
-#define PRL_TX_SET_FLAG(port, flag) atomic_or(&prl_tx[port].flags, (flag))
-#define PRL_TX_CLR_FLAG(port, flag) atomic_clear(&prl_tx[port].flags, (flag))
+#define PRL_TX_SET_FLAG(port, flag) \
+	deprecated_atomic_or(&prl_tx[port].flags, (flag))
+#define PRL_TX_CLR_FLAG(port, flag) \
+	deprecated_atomic_clear(&prl_tx[port].flags, (flag))
 #define PRL_TX_CHK_FLAG(port, flag) (prl_tx[port].flags & (flag))
 
-#define PRL_HR_SET_FLAG(port, flag) atomic_or(&prl_hr[port].flags, (flag))
-#define PRL_HR_CLR_FLAG(port, flag) atomic_clear(&prl_hr[port].flags, (flag))
+#define PRL_HR_SET_FLAG(port, flag) \
+	deprecated_atomic_or(&prl_hr[port].flags, (flag))
+#define PRL_HR_CLR_FLAG(port, flag) \
+	deprecated_atomic_clear(&prl_hr[port].flags, (flag))
 #define PRL_HR_CHK_FLAG(port, flag) (prl_hr[port].flags & (flag))
 
-#define PDMSG_SET_FLAG(port, flag) atomic_or(&pdmsg[port].flags, (flag))
-#define PDMSG_CLR_FLAG(port, flag) atomic_clear(&pdmsg[port].flags, (flag))
+#define PDMSG_SET_FLAG(port, flag) \
+	deprecated_atomic_or(&pdmsg[port].flags, (flag))
+#define PDMSG_CLR_FLAG(port, flag) \
+	deprecated_atomic_clear(&pdmsg[port].flags, (flag))
 #define PDMSG_CHK_FLAG(port, flag) (pdmsg[port].flags & (flag))
 
 /* Protocol Layer Flags */
diff --git a/common/usbc/usb_tc_drp_acc_trysrc_sm.c b/common/usbc/usb_tc_drp_acc_trysrc_sm.c
index eb1c944072..2a5ac25944 100644
--- a/common/usbc/usb_tc_drp_acc_trysrc_sm.c
+++ b/common/usbc/usb_tc_drp_acc_trysrc_sm.c
@@ -59,16 +59,20 @@
 #undef DEBUG_PRINT_FLAG_AND_EVENT_NAMES
 
 #ifdef DEBUG_PRINT_FLAG_AND_EVENT_NAMES
-	void print_flag(int set_or_clear, int flag);
-	#define TC_SET_FLAG(port, flag) do { \
-		print_flag(1, flag); atomic_or(&tc[port].flags, (flag)); \
+void print_flag(int set_or_clear, int flag);
+#define TC_SET_FLAG(port, flag)                                \
+	do {                                                   \
+		print_flag(1, flag);                           \
+		deprecated_atomic_or(&tc[port].flags, (flag)); \
 	} while (0)
-	#define TC_CLR_FLAG(port, flag) do { \
-		print_flag(0, flag); atomic_clear(&tc[port].flags, (flag)); \
+#define TC_CLR_FLAG(port, flag)                                   \
+	do {                                                      \
+		print_flag(0, flag);                              \
+		deprecated_atomic_clear(&tc[port].flags, (flag)); \
 	} while (0)
 #else
-	#define TC_SET_FLAG(port, flag) atomic_or(&tc[port].flags, (flag))
-	#define TC_CLR_FLAG(port, flag) atomic_clear(&tc[port].flags, (flag))
+#define TC_SET_FLAG(port, flag) deprecated_atomic_or(&tc[port].flags, (flag))
+#define TC_CLR_FLAG(port, flag) deprecated_atomic_clear(&tc[port].flags, (flag))
 #endif
 #define TC_CHK_FLAG(port, flag) (tc[port].flags & (flag))
 
@@ -603,9 +607,11 @@ static bool pd_comm_allowed_by_policy(void)
 static void tc_policy_pd_enable(int port, int en)
 {
 	if (en)
-		atomic_clear(&tc[port].pd_disabled_mask, PD_DISABLED_BY_POLICY);
+		deprecated_atomic_clear(&tc[port].pd_disabled_mask,
+					PD_DISABLED_BY_POLICY);
 	else
-		atomic_or(&tc[port].pd_disabled_mask, PD_DISABLED_BY_POLICY);
+		deprecated_atomic_or(&tc[port].pd_disabled_mask,
+				     PD_DISABLED_BY_POLICY);
 
 	CPRINTS("C%d: PD comm policy %sabled", port, en ? "en" : "dis");
 }
@@ -613,20 +619,19 @@ static void tc_policy_pd_enable(int port, int en)
 static void tc_enable_pd(int port, int en)
 {
 	if (en)
-		atomic_clear(&tc[port].pd_disabled_mask,
-						PD_DISABLED_NO_CONNECTION);
+		deprecated_atomic_clear(&tc[port].pd_disabled_mask,
+					PD_DISABLED_NO_CONNECTION);
 	else
-		atomic_or(&tc[port].pd_disabled_mask,
-						PD_DISABLED_NO_CONNECTION);
-
+		deprecated_atomic_or(&tc[port].pd_disabled_mask,
+				     PD_DISABLED_NO_CONNECTION);
 }
 
 static void tc_enable_try_src(int en)
 {
 	if (en)
-		atomic_or(&pd_try_src, 1);
+		deprecated_atomic_or(&pd_try_src, 1);
 	else
-		atomic_clear(&pd_try_src, 1);
+		deprecated_atomic_clear(&pd_try_src, 1);
 }
 
 static void tc_detached(int port)
@@ -1743,10 +1748,11 @@ static __maybe_unused int reset_device_and_notify(int port)
 	 * waking the TCPC, but it has also set PD_EVENT_TCPC_RESET again, which
 	 * would result in a second, unnecessary init.
 	 */
-	atomic_clear(task_get_event_bitmap(task_get_current()),
-		PD_EVENT_TCPC_RESET);
+	deprecated_atomic_clear(task_get_event_bitmap(task_get_current()),
+				PD_EVENT_TCPC_RESET);
 
-	waiting_tasks = atomic_read_clear(&tc[port].tasks_waiting_on_reset);
+	waiting_tasks =
+		deprecated_atomic_read_clear(&tc[port].tasks_waiting_on_reset);
 
 	/* Wake up all waiting tasks. */
 	while (waiting_tasks) {
@@ -1769,8 +1775,8 @@ void pd_wait_exit_low_power(int port)
 			reset_device_and_notify(port);
 	} else {
 		/* Otherwise, we need to wait for the TCPC reset to complete */
-		atomic_or(&tc[port].tasks_waiting_on_reset,
-			  1 << task_get_current());
+		deprecated_atomic_or(&tc[port].tasks_waiting_on_reset,
+				     1 << task_get_current());
 		/*
 		 * NOTE: We could be sending the PD task the reset event while
 		 * it is already processing the reset event. If that occurs,
@@ -1810,9 +1816,11 @@ void pd_prevent_low_power_mode(int port, int prevent)
 		return;
 
 	if (prevent)
-		atomic_or(&tc[port].tasks_preventing_lpm, current_task_mask);
+		deprecated_atomic_or(&tc[port].tasks_preventing_lpm,
+				     current_task_mask);
 	else
-		atomic_clear(&tc[port].tasks_preventing_lpm, current_task_mask);
+		deprecated_atomic_clear(&tc[port].tasks_preventing_lpm,
+					current_task_mask);
 }
 #endif /* CONFIG_USB_PD_TCPC_LOW_POWER */
 
diff --git a/common/usbc_ppc.c b/common/usbc_ppc.c
index 3430a41879..7b01ed4591 100644
--- a/common/usbc_ppc.c
+++ b/common/usbc_ppc.c
@@ -82,7 +82,7 @@ int ppc_add_oc_event(int port)
 	oc_event_cnt_tbl[port]++;
 
 	/* The port overcurrented, so don't clear it's OC events. */
-	atomic_clear(&connected_ports, 1 << port);
+	deprecated_atomic_clear(&connected_ports, 1 << port);
 
 	if (oc_event_cnt_tbl[port] >= PPC_OC_CNT_THRESH)
 		ppc_prints("OC event limit reached! "
@@ -264,9 +264,9 @@ void ppc_sink_is_connected(int port, int is_connected)
 	}
 
 	if (is_connected)
-		atomic_or(&connected_ports, 1 << port);
+		deprecated_atomic_or(&connected_ports, 1 << port);
 	else
-		atomic_clear(&connected_ports, 1 << port);
+		deprecated_atomic_clear(&connected_ports, 1 << port);
 }
 
 int ppc_vbus_sink_enable(int port, int enable)
diff --git a/core/cortex-m/atomic.h b/core/cortex-m/atomic.h
index 2b2b6153ba..4d56ce3e4e 100644
--- a/core/cortex-m/atomic.h
+++ b/core/cortex-m/atomic.h
@@ -30,27 +30,36 @@
 			     : "r" (a), "r" (v) : "cc");        \
 } while (0)
 
-static inline void atomic_clear(uint32_t volatile *addr, uint32_t bits)
+/*
+ * The atomic_* functions are marked as deprecated as a part of the process of
+ * transaction to Zephyr compatible atomic functions. These prefixes will be
+ * removed in the following patches. Please see b:169151160 for more details.
+ */
+
+static inline void deprecated_atomic_clear(uint32_t volatile *addr,
+					   uint32_t bits)
 {
 	ATOMIC_OP(bic, addr, bits);
 }
 
-static inline void atomic_or(uint32_t volatile *addr, uint32_t bits)
+static inline void deprecated_atomic_or(uint32_t volatile *addr, uint32_t bits)
 {
 	ATOMIC_OP(orr, addr, bits);
 }
 
-static inline void atomic_add(uint32_t volatile *addr, uint32_t value)
+static inline void deprecated_atomic_add(uint32_t volatile *addr,
+					 uint32_t value)
 {
 	ATOMIC_OP(add, addr, value);
 }
 
-static inline void atomic_sub(uint32_t volatile *addr, uint32_t value)
+static inline void deprecated_atomic_sub(uint32_t volatile *addr,
+					 uint32_t value)
 {
 	ATOMIC_OP(sub, addr, value);
 }
 
-static inline uint32_t atomic_read_clear(uint32_t volatile *addr)
+static inline uint32_t deprecated_atomic_read_clear(uint32_t volatile *addr)
 {
 	uint32_t ret, tmp;
 
diff --git a/core/cortex-m/task.c b/core/cortex-m/task.c
index d64f9400b6..058b892a46 100644
--- a/core/cortex-m/task.c
+++ b/core/cortex-m/task.c
@@ -413,7 +413,7 @@ static uint32_t __wait_evt(int timeout_us, task_id_t resched)
 		ret = timer_arm(deadline, me);
 		ASSERT(ret == EC_SUCCESS);
 	}
-	while (!(evt = atomic_read_clear(&tsk->events))) {
+	while (!(evt = deprecated_atomic_read_clear(&tsk->events))) {
 		/* Remove ourself and get the next task in the scheduler */
 		__schedule(1, resched);
 		resched = TASK_ID_IDLE;
@@ -421,7 +421,7 @@ static uint32_t __wait_evt(int timeout_us, task_id_t resched)
 	if (timeout_us > 0) {
 		timer_cancel(me);
 		/* Ensure timer event is clear, we no longer care about it */
-		atomic_clear(&tsk->events, TASK_EVENT_TIMER);
+		deprecated_atomic_clear(&tsk->events, TASK_EVENT_TIMER);
 	}
 	return evt;
 }
@@ -432,12 +432,12 @@ uint32_t task_set_event(task_id_t tskid, uint32_t event, int wait)
 	ASSERT(receiver);
 
 	/* Set the event bit in the receiver message bitmap */
-	atomic_or(&receiver->events, event);
+	deprecated_atomic_or(&receiver->events, event);
 
 	/* Re-schedule if priorities have changed */
 	if (in_interrupt_context()) {
 		/* The receiver might run again */
-		atomic_or(&tasks_ready, 1 << tskid);
+		deprecated_atomic_or(&tasks_ready, 1 << tskid);
 #ifndef CONFIG_TASK_PROFILING
 		if (start_called)
 			need_resched_or_profiling = 1;
@@ -480,7 +480,8 @@ uint32_t task_wait_event_mask(uint32_t event_mask, int timeout_us)
 
 	/* Re-post any other events collected */
 	if (events & ~event_mask)
-		atomic_or(&current_task->events, events & ~event_mask);
+		deprecated_atomic_or(&current_task->events,
+				     events & ~event_mask);
 
 	return events & event_mask;
 }
@@ -495,12 +496,12 @@ void task_enable_all_tasks(void)
 
 void task_enable_task(task_id_t tskid)
 {
-	atomic_or(&tasks_enabled, BIT(tskid));
+	deprecated_atomic_or(&tasks_enabled, BIT(tskid));
 }
 
 void task_disable_task(task_id_t tskid)
 {
-	atomic_clear(&tasks_enabled, BIT(tskid));
+	deprecated_atomic_clear(&tasks_enabled, BIT(tskid));
 
 	if (!in_interrupt_context() && tskid == task_get_current())
 		__schedule(0, 0);
@@ -578,7 +579,8 @@ static void deferred_task_reset(void)
 	while (deferred_reset_task_ids) {
 		task_id_t reset_id = __fls(deferred_reset_task_ids);
 
-		atomic_clear(&deferred_reset_task_ids, 1 << reset_id);
+		deprecated_atomic_clear(&deferred_reset_task_ids,
+					1 << reset_id);
 		do_task_reset(reset_id);
 	}
 }
@@ -673,7 +675,7 @@ void task_enable_resets(void)
 		return;
 
 	/* People are waiting for us to reset; schedule a reset. */
-	atomic_or(&deferred_reset_task_ids, 1 << id);
+	deprecated_atomic_or(&deferred_reset_task_ids, 1 << id);
 	/*
 	 * This will always trigger a deferred call after our new ID was
 	 * written. If the hook call is currently executing, it will run
@@ -758,7 +760,7 @@ int task_reset_cleanup(void)
 			 * itself back to the list of tasks to notify,
 			 * and we will notify it again.
 			 */
-			atomic_clear(state, 1 << notify_id);
+			deprecated_atomic_clear(state, 1 << notify_id);
 			/*
 			 * Skip any invalid ids set by tasks that
 			 * requested a non-blocking reset.
@@ -876,7 +878,7 @@ void mutex_lock(struct mutex *mtx)
 
 	id = 1 << task_get_current();
 
-	atomic_or(&mtx->waiters, id);
+	deprecated_atomic_or(&mtx->waiters, id);
 
 	do {
 		/* Try to get the lock (set 1 into the lock field) */
@@ -895,7 +897,7 @@ void mutex_lock(struct mutex *mtx)
 			task_wait_event_mask(TASK_EVENT_MUTEX, 0);
 	} while (value);
 
-	atomic_clear(&mtx->waiters, id);
+	deprecated_atomic_clear(&mtx->waiters, id);
 }
 
 void mutex_unlock(struct mutex *mtx)
@@ -921,7 +923,7 @@ void mutex_unlock(struct mutex *mtx)
 	}
 
 	/* Ensure no event is remaining from mutex wake-up */
-	atomic_clear(&tsk->events, TASK_EVENT_MUTEX);
+	deprecated_atomic_clear(&tsk->events, TASK_EVENT_MUTEX);
 }
 
 void task_print_list(void)
diff --git a/core/cortex-m0/atomic.h b/core/cortex-m0/atomic.h
index 417c86a6c9..414e6a56c1 100644
--- a/core/cortex-m0/atomic.h
+++ b/core/cortex-m0/atomic.h
@@ -27,27 +27,36 @@
 			     : "b" (a), "r" (v) : "cc");	\
 } while (0)
 
-static inline void atomic_clear(uint32_t volatile *addr, uint32_t bits)
+/*
+ * The atomic_* functions are marked as deprecated as a part of the process of
+ * transaction to Zephyr compatible atomic functions. These prefixes will be
+ * removed in the following patches. Please see b:169151160 for more details.
+ */
+
+static inline void deprecated_atomic_clear(uint32_t volatile *addr,
+					   uint32_t bits)
 {
 	ATOMIC_OP(bic, addr, bits);
 }
 
-static inline void atomic_or(uint32_t volatile *addr, uint32_t bits)
+static inline void deprecated_atomic_or(uint32_t volatile *addr, uint32_t bits)
 {
 	ATOMIC_OP(orr, addr, bits);
 }
 
-static inline void atomic_add(uint32_t volatile *addr, uint32_t value)
+static inline void deprecated_atomic_add(uint32_t volatile *addr,
+					 uint32_t value)
 {
 	ATOMIC_OP(add, addr, value);
 }
 
-static inline void atomic_sub(uint32_t volatile *addr, uint32_t value)
+static inline void deprecated_atomic_sub(uint32_t volatile *addr,
+					 uint32_t value)
 {
 	ATOMIC_OP(sub, addr, value);
 }
 
-static inline uint32_t atomic_read_clear(uint32_t volatile *addr)
+static inline uint32_t deprecated_atomic_read_clear(uint32_t volatile *addr)
 {
 	uint32_t ret;
 
diff --git a/core/cortex-m0/task.c b/core/cortex-m0/task.c
index 5fa884fc3e..657ed88a73 100644
--- a/core/cortex-m0/task.c
+++ b/core/cortex-m0/task.c
@@ -334,7 +334,7 @@ static uint32_t __wait_evt(int timeout_us, task_id_t resched)
 		ret = timer_arm(deadline, me);
 		ASSERT(ret == EC_SUCCESS);
 	}
-	while (!(evt = atomic_read_clear(&tsk->events))) {
+	while (!(evt = deprecated_atomic_read_clear(&tsk->events))) {
 		/*
 		 * We need to ensure that the execution priority is actually
 		 * decreased after the "cpsie i" in the atomic operation above
@@ -349,7 +349,7 @@ static uint32_t __wait_evt(int timeout_us, task_id_t resched)
 	if (timeout_us > 0) {
 		timer_cancel(me);
 		/* Ensure timer event is clear, we no longer care about it */
-		atomic_clear(&tsk->events, TASK_EVENT_TIMER);
+		deprecated_atomic_clear(&tsk->events, TASK_EVENT_TIMER);
 	}
 	return evt;
 }
@@ -360,12 +360,12 @@ uint32_t task_set_event(task_id_t tskid, uint32_t event, int wait)
 	ASSERT(receiver);
 
 	/* Set the event bit in the receiver message bitmap */
-	atomic_or(&receiver->events, event);
+	deprecated_atomic_or(&receiver->events, event);
 
 	/* Re-schedule if priorities have changed */
 	if (in_interrupt_context()) {
 		/* The receiver might run again */
-		atomic_or(&tasks_ready, 1 << tskid);
+		deprecated_atomic_or(&tasks_ready, 1 << tskid);
 		if (start_called) {
 			/*
 			 * Trigger the scheduler when there's
@@ -420,7 +420,8 @@ uint32_t task_wait_event_mask(uint32_t event_mask, int timeout_us)
 
 	/* Re-post any other events collected */
 	if (events & ~event_mask)
-		atomic_or(&current_task->events, events & ~event_mask);
+		deprecated_atomic_or(&current_task->events,
+				     events & ~event_mask);
 
 	return events & event_mask;
 }
@@ -435,12 +436,12 @@ void task_enable_all_tasks(void)
 
 void task_enable_task(task_id_t tskid)
 {
-	atomic_or(&tasks_enabled, BIT(tskid));
+	deprecated_atomic_or(&tasks_enabled, BIT(tskid));
 }
 
 void task_disable_task(task_id_t tskid)
 {
-	atomic_clear(&tasks_enabled, BIT(tskid));
+	deprecated_atomic_clear(&tasks_enabled, BIT(tskid));
 
 	if (!in_interrupt_context() && tskid == task_get_current())
 		__schedule(0, 0);
@@ -499,7 +500,7 @@ void mutex_lock(struct mutex *mtx)
 	uint32_t id = 1 << task_get_current();
 
 	ASSERT(id != TASK_ID_INVALID);
-	atomic_or(&mtx->waiters, id);
+	deprecated_atomic_or(&mtx->waiters, id);
 
 	while (1) {
 		/* Try to get the lock (set 2 into the lock field) */
@@ -513,7 +514,7 @@ void mutex_lock(struct mutex *mtx)
 	mtx->lock = 2;
 	__asm__ __volatile__("cpsie i");
 
-	atomic_clear(&mtx->waiters, id);
+	deprecated_atomic_clear(&mtx->waiters, id);
 }
 
 void mutex_unlock(struct mutex *mtx)
@@ -539,7 +540,7 @@ void mutex_unlock(struct mutex *mtx)
 	}
 
 	/* Ensure no event is remaining from mutex wake-up */
-	atomic_clear(&tsk->events, TASK_EVENT_MUTEX);
+	deprecated_atomic_clear(&tsk->events, TASK_EVENT_MUTEX);
 }
 
 void task_print_list(void)
diff --git a/core/host/atomic.h b/core/host/atomic.h
index b6e60e40b5..4150a20216 100644
--- a/core/host/atomic.h
+++ b/core/host/atomic.h
@@ -10,27 +10,36 @@
 
 #include "common.h"
 
-static inline void atomic_clear(uint32_t volatile *addr, uint32_t bits)
+/*
+ * The atomic_* functions are marked as deprecated as a part of the process of
+ * transaction to Zephyr compatible atomic functions. These prefixes will be
+ * removed in the following patches. Please see b:169151160 for more details.
+ */
+
+static inline void deprecated_atomic_clear(uint32_t volatile *addr,
+					   uint32_t bits)
 {
 	__sync_and_and_fetch(addr, ~bits);
 }
 
-static inline void atomic_or(uint32_t volatile *addr, uint32_t bits)
+static inline void deprecated_atomic_or(uint32_t volatile *addr, uint32_t bits)
 {
 	__sync_or_and_fetch(addr, bits);
 }
 
-static inline void atomic_add(uint32_t volatile *addr, uint32_t value)
+static inline void deprecated_atomic_add(uint32_t volatile *addr,
+					 uint32_t value)
 {
 	__sync_add_and_fetch(addr, value);
 }
 
-static inline void atomic_sub(uint32_t volatile *addr, uint32_t value)
+static inline void deprecated_atomic_sub(uint32_t volatile *addr,
+					 uint32_t value)
 {
 	__sync_sub_and_fetch(addr, value);
 }
 
-static inline uint32_t atomic_read_clear(uint32_t volatile *addr)
+static inline uint32_t deprecated_atomic_read_clear(uint32_t volatile *addr)
 {
 	return __sync_fetch_and_and(addr, 0);
 }
diff --git a/core/host/task.c b/core/host/task.c
index 7bd44c61b9..ae5e525303 100644
--- a/core/host/task.c
+++ b/core/host/task.c
@@ -200,7 +200,7 @@ pthread_t task_get_thread(task_id_t tskid)
 
 uint32_t task_set_event(task_id_t tskid, uint32_t event, int wait)
 {
-	atomic_or(&tasks[tskid].event, event);
+	deprecated_atomic_or(&tasks[tskid].event, event);
 	if (wait)
 		return task_wait_event(-1);
 	return 0;
@@ -224,7 +224,7 @@ uint32_t task_wait_event(int timeout_us)
 	pthread_cond_wait(&tasks[tid].resume, &run_lock);
 
 	/* Resume */
-	ret = atomic_read_clear(&tasks[tid].event);
+	ret = deprecated_atomic_read_clear(&tasks[tid].event);
 	pthread_mutex_unlock(&interrupt_lock);
 	return ret;
 }
@@ -252,8 +252,8 @@ uint32_t task_wait_event_mask(uint32_t event_mask, int timeout_us)
 
 	/* Re-post any other events collected */
 	if (events & ~event_mask)
-		atomic_or(&tasks[task_get_current()].event,
-				events & ~event_mask);
+		deprecated_atomic_or(&tasks[task_get_current()].event,
+				     events & ~event_mask);
 
 	return events & event_mask;
 }
diff --git a/core/minute-ia/atomic.h b/core/minute-ia/atomic.h
index a944127fa1..89ed35340c 100644
--- a/core/minute-ia/atomic.h
+++ b/core/minute-ia/atomic.h
@@ -32,42 +32,52 @@ static inline int bool_compare_and_swap_u32(uint32_t *var, uint32_t old_value,
 	return (_old_value == old_value);
 }
 
-static inline void atomic_or_u8(uint8_t *addr, uint8_t bits)
+/*
+ * The atomic_* functions are marked as deprecated as a part of the process of
+ * transaction to Zephyr compatible atomic functions. These prefixes will be
+ * removed in the following patches. Please see b:169151160 for more details.
+ */
+
+static inline void deprecated_atomic_or_u8(uint8_t *addr, uint8_t bits)
 {
 	ATOMIC_OP(or, addr, bits);
 }
 
-static inline void atomic_and_u8(uint8_t *addr, uint8_t bits)
+static inline void deprecated_atomic_and_u8(uint8_t *addr, uint8_t bits)
 {
 	ATOMIC_OP(and, addr, bits);
 }
 
-static inline void atomic_clear(uint32_t volatile *addr, uint32_t bits)
+static inline void deprecated_atomic_clear(uint32_t volatile *addr,
+					   uint32_t bits)
 {
 	ATOMIC_OP(andl, addr, ~bits);
 }
 
-static inline void atomic_or(uint32_t volatile *addr, uint32_t bits)
+static inline void deprecated_atomic_or(uint32_t volatile *addr, uint32_t bits)
 {
 	ATOMIC_OP(orl, addr, bits);
 }
 
-static inline void atomic_add(uint32_t volatile *addr, uint32_t value)
+static inline void deprecated_atomic_add(uint32_t volatile *addr,
+					 uint32_t value)
 {
 	ATOMIC_OP(addl, addr, value);
 }
 
-static inline void atomic_and(uint32_t volatile *addr, uint32_t value)
+static inline void deprecated_atomic_and(uint32_t volatile *addr,
+					 uint32_t value)
 {
 	ATOMIC_OP(andl, addr, value);
 }
 
-static inline void atomic_sub(uint32_t volatile *addr, uint32_t value)
+static inline void deprecated_atomic_sub(uint32_t volatile *addr,
+					 uint32_t value)
 {
 	ATOMIC_OP(subl, addr, value);
 }
 
-static inline uint32_t atomic_read_clear(uint32_t volatile *addr)
+static inline uint32_t deprecated_atomic_read_clear(uint32_t volatile *addr)
 {
 	int ret = 0;
 
diff --git a/core/minute-ia/task.c b/core/minute-ia/task.c
index 7e7c836f7e..f0296596b1 100644
--- a/core/minute-ia/task.c
+++ b/core/minute-ia/task.c
@@ -287,7 +287,7 @@ void __keep task_start_irq_handler(void *data)
 		irq_dist[irq]++;
 	else
 		/* Track total number of service calls */
-		atomic_add(&svc_calls, 1);
+		deprecated_atomic_add(&svc_calls, 1);
 
 	/* Only the outer ISR should keep track of the ISR start time */
 	if (__in_isr == 1) {
@@ -318,7 +318,7 @@ static uint32_t __wait_evt(int timeout_us, task_id_t resched)
 		ret = timer_arm(deadline, me);
 		ASSERT(ret == EC_SUCCESS);
 	}
-	while (!(evt = atomic_read_clear(&tsk->events))) {
+	while (!(evt = deprecated_atomic_read_clear(&tsk->events))) {
 		/* Remove ourself and get the next task in the scheduler */
 		__schedule(1, resched);
 		resched = TASK_ID_IDLE;
@@ -326,7 +326,7 @@ static uint32_t __wait_evt(int timeout_us, task_id_t resched)
 	if (timeout_us > 0) {
 		timer_cancel(me);
 		/* Ensure timer event is clear, we no longer care about it */
-		atomic_clear(&tsk->events, TASK_EVENT_TIMER);
+		deprecated_atomic_clear(&tsk->events, TASK_EVENT_TIMER);
 	}
 	return evt;
 }
@@ -345,12 +345,12 @@ uint32_t task_set_event(task_id_t tskid, uint32_t event, int wait)
 	ASSERT(receiver);
 
 	/* Set the event bit in the receiver message bitmap */
-	atomic_or(&receiver->events, event);
+	deprecated_atomic_or(&receiver->events, event);
 
 	/* Re-schedule if priorities have changed */
 	if (in_interrupt_context()) {
 		/* The receiver might run again */
-		atomic_or(&tasks_ready, 1 << tskid);
+		deprecated_atomic_or(&tasks_ready, 1 << tskid);
 	} else {
 		if (wait)
 			return __wait_evt(-1, tskid);
@@ -389,7 +389,8 @@ uint32_t task_wait_event_mask(uint32_t event_mask, int timeout_us)
 
 	/* Re-post any other events collected */
 	if (events & ~event_mask)
-		atomic_or(&current_task->events, events & ~event_mask);
+		deprecated_atomic_or(&current_task->events,
+				     events & ~event_mask);
 
 	return events & event_mask;
 }
@@ -405,12 +406,12 @@ void task_enable_all_tasks(void)
 
 void task_enable_task(task_id_t tskid)
 {
-	atomic_or(&tasks_enabled, BIT(tskid));
+	deprecated_atomic_or(&tasks_enabled, BIT(tskid));
 }
 
 void task_disable_task(task_id_t tskid)
 {
-	atomic_clear(&tasks_enabled, BIT(tskid));
+	deprecated_atomic_clear(&tasks_enabled, BIT(tskid));
 
 	if (!in_interrupt_context() && tskid == task_get_current())
 		__schedule(0, 0);
@@ -454,7 +455,7 @@ void mutex_lock(struct mutex *mtx)
 	uint32_t id = 1 << task_get_current();
 
 	ASSERT(id != TASK_ID_INVALID);
-	atomic_or(&mtx->waiters, id);
+	deprecated_atomic_or(&mtx->waiters, id);
 
 	do {
 		old_val = 0;
@@ -470,7 +471,7 @@ void mutex_lock(struct mutex *mtx)
 		}
 	} while (old_val);
 
-	atomic_clear(&mtx->waiters, id);
+	deprecated_atomic_clear(&mtx->waiters, id);
 }
 
 void mutex_unlock(struct mutex *mtx)
@@ -497,7 +498,7 @@ void mutex_unlock(struct mutex *mtx)
 	}
 
 	/* Ensure no event is remaining from mutex wake-up */
-	atomic_clear(&tsk->events, TASK_EVENT_MUTEX);
+	deprecated_atomic_clear(&tsk->events, TASK_EVENT_MUTEX);
 }
 
 void task_print_list(void)
diff --git a/core/nds32/atomic.h b/core/nds32/atomic.h
index 792093d598..e10a35aa54 100644
--- a/core/nds32/atomic.h
+++ b/core/nds32/atomic.h
@@ -12,7 +12,14 @@
 #include "cpu.h"
 #include "task.h"
 
-static inline void atomic_clear(uint32_t volatile *addr, uint32_t bits)
+/*
+ * The atomic_* functions are marked as deprecated as a part of the process of
+ * transaction to Zephyr compatible atomic functions. These prefixes will be
+ * removed in the following patches. Please see b:169151160 for more details.
+ */
+
+static inline void deprecated_atomic_clear(uint32_t volatile *addr,
+					   uint32_t bits)
 {
 	uint32_t int_mask = read_clear_int_mask();
 
@@ -20,7 +27,7 @@ static inline void atomic_clear(uint32_t volatile *addr, uint32_t bits)
 	set_int_mask(int_mask);
 }
 
-static inline void atomic_or(uint32_t volatile *addr, uint32_t bits)
+static inline void deprecated_atomic_or(uint32_t volatile *addr, uint32_t bits)
 {
 	uint32_t int_mask = read_clear_int_mask();
 
@@ -28,7 +35,8 @@ static inline void atomic_or(uint32_t volatile *addr, uint32_t bits)
 	set_int_mask(int_mask);
 }
 
-static inline void atomic_add(uint32_t volatile *addr, uint32_t value)
+static inline void deprecated_atomic_add(uint32_t volatile *addr,
+					 uint32_t value)
 {
 	uint32_t int_mask = read_clear_int_mask();
 
@@ -36,7 +44,8 @@ static inline void atomic_add(uint32_t volatile *addr, uint32_t value)
 	set_int_mask(int_mask);
 }
 
-static inline void atomic_sub(uint32_t volatile *addr, uint32_t value)
+static inline void deprecated_atomic_sub(uint32_t volatile *addr,
+					 uint32_t value)
 {
 	uint32_t int_mask = read_clear_int_mask();
 
@@ -44,7 +53,7 @@ static inline void atomic_sub(uint32_t volatile *addr, uint32_t value)
 	set_int_mask(int_mask);
 }
 
-static inline uint32_t atomic_read_clear(uint32_t volatile *addr)
+static inline uint32_t deprecated_atomic_read_clear(uint32_t volatile *addr)
 {
 	uint32_t val;
 	uint32_t int_mask = read_clear_int_mask();
diff --git a/core/nds32/task.c b/core/nds32/task.c
index 21bd8d5edd..c6ae32912e 100644
--- a/core/nds32/task.c
+++ b/core/nds32/task.c
@@ -403,7 +403,7 @@ static uint32_t __ram_code __wait_evt(int timeout_us, task_id_t resched)
 		ret = timer_arm(deadline, me);
 		ASSERT(ret == EC_SUCCESS);
 	}
-	while (!(evt = atomic_read_clear(&tsk->events))) {
+	while (!(evt = deprecated_atomic_read_clear(&tsk->events))) {
 		/* Remove ourself and get the next task in the scheduler */
 		__schedule(1, resched, 0);
 		resched = TASK_ID_IDLE;
@@ -411,7 +411,7 @@ static uint32_t __ram_code __wait_evt(int timeout_us, task_id_t resched)
 	if (timeout_us > 0) {
 		timer_cancel(me);
 		/* Ensure timer event is clear, we no longer care about it */
-		atomic_clear(&tsk->events, TASK_EVENT_TIMER);
+		deprecated_atomic_clear(&tsk->events, TASK_EVENT_TIMER);
 	}
 	return evt;
 }
@@ -422,12 +422,12 @@ uint32_t __ram_code task_set_event(task_id_t tskid, uint32_t event, int wait)
 	ASSERT(receiver);
 
 	/* Set the event bit in the receiver message bitmap */
-	atomic_or(&receiver->events, event);
+	deprecated_atomic_or(&receiver->events, event);
 
 	/* Re-schedule if priorities have changed */
 	if (in_interrupt_context()) {
 		/* The receiver might run again */
-		atomic_or(&tasks_ready, 1 << tskid);
+		deprecated_atomic_or(&tasks_ready, 1 << tskid);
 		if (start_called)
 			need_resched = 1;
 	} else {
@@ -468,7 +468,8 @@ uint32_t __ram_code task_wait_event_mask(uint32_t event_mask, int timeout_us)
 
 	/* Re-post any other events collected */
 	if (events & ~event_mask)
-		atomic_or(&current_task->events, events & ~event_mask);
+		deprecated_atomic_or(&current_task->events,
+				     events & ~event_mask);
 
 	return events & event_mask;
 }
@@ -520,12 +521,12 @@ void task_enable_all_tasks(void)
 
 void task_enable_task(task_id_t tskid)
 {
-	atomic_or(&tasks_enabled, BIT(tskid));
+	deprecated_atomic_or(&tasks_enabled, BIT(tskid));
 }
 
 void task_disable_task(task_id_t tskid)
 {
-	atomic_clear(&tasks_enabled, BIT(tskid));
+	deprecated_atomic_clear(&tasks_enabled, BIT(tskid));
 
 	if (!in_interrupt_context() && tskid == task_get_current())
 		__schedule(0, 0, 0);
@@ -643,7 +644,7 @@ void __ram_code mutex_unlock(struct mutex *mtx)
 	}
 
 	/* Ensure no event is remaining from mutex wake-up */
-	atomic_clear(&tsk->events, TASK_EVENT_MUTEX);
+	deprecated_atomic_clear(&tsk->events, TASK_EVENT_MUTEX);
 }
 
 void task_print_list(void)
diff --git a/core/riscv-rv32i/atomic.h b/core/riscv-rv32i/atomic.h
index d9f25cd38d..a9e4df0344 100644
--- a/core/riscv-rv32i/atomic.h
+++ b/core/riscv-rv32i/atomic.h
@@ -22,37 +22,48 @@
 	tmp;                                   \
 })
 
-static inline void atomic_clear(volatile uint32_t *addr, uint32_t bits)
+/*
+ * The atomic_* functions are marked as deprecated as a part of the process of
+ * transaction to Zephyr compatible atomic functions. These prefixes will be
+ * removed in the following patches. Please see b:169151160 for more details.
+ */
+
+static inline void deprecated_atomic_clear(volatile uint32_t *addr,
+					   uint32_t bits)
 {
 	ATOMIC_OP(and, ~bits, addr);
 }
 
-static inline void atomic_or(volatile uint32_t *addr, uint32_t bits)
+static inline void deprecated_atomic_or(volatile uint32_t *addr, uint32_t bits)
 {
 	ATOMIC_OP(or, bits, addr);
 }
 
-static inline void atomic_add(volatile uint32_t *addr, uint32_t value)
+static inline void deprecated_atomic_add(volatile uint32_t *addr,
+					 uint32_t value)
 {
 	ATOMIC_OP(add, value, addr);
 }
 
-static inline void atomic_sub(volatile uint32_t *addr, uint32_t value)
+static inline void deprecated_atomic_sub(volatile uint32_t *addr,
+					 uint32_t value)
 {
 	ATOMIC_OP(add, -value, addr);
 }
 
-static inline uint32_t atomic_read_clear(volatile uint32_t *addr)
+static inline uint32_t deprecated_atomic_read_clear(volatile uint32_t *addr)
 {
 	return ATOMIC_OP(and, 0, addr);
 }
 
-static inline uint32_t atomic_inc(volatile uint32_t *addr, uint32_t value)
+static inline uint32_t deprecated_atomic_inc(volatile uint32_t *addr,
+					     uint32_t value)
 {
 	return ATOMIC_OP(add, value, addr);
 }
 
-static inline uint32_t atomic_dec(volatile uint32_t *addr, uint32_t value)
+static inline uint32_t deprecated_atomic_dec(volatile uint32_t *addr,
+					     uint32_t value)
 {
 	return ATOMIC_OP(add, -value, addr);
 }
diff --git a/core/riscv-rv32i/task.c b/core/riscv-rv32i/task.c
index 3ad78994bd..862f9e3b81 100644
--- a/core/riscv-rv32i/task.c
+++ b/core/riscv-rv32i/task.c
@@ -397,7 +397,7 @@ static uint32_t __ram_code __wait_evt(int timeout_us, task_id_t resched)
 		ret = timer_arm(deadline, me);
 		ASSERT(ret == EC_SUCCESS);
 	}
-	while (!(evt = atomic_read_clear(&tsk->events))) {
+	while (!(evt = deprecated_atomic_read_clear(&tsk->events))) {
 		/* Remove ourself and get the next task in the scheduler */
 		__schedule(1, resched, 0);
 		resched = TASK_ID_IDLE;
@@ -405,7 +405,7 @@ static uint32_t __ram_code __wait_evt(int timeout_us, task_id_t resched)
 	if (timeout_us > 0) {
 		timer_cancel(me);
 		/* Ensure timer event is clear, we no longer care about it */
-		atomic_clear(&tsk->events, TASK_EVENT_TIMER);
+		deprecated_atomic_clear(&tsk->events, TASK_EVENT_TIMER);
 	}
 	return evt;
 }
@@ -417,12 +417,12 @@ uint32_t __ram_code task_set_event(task_id_t tskid, uint32_t event, int wait)
 	ASSERT(receiver);
 
 	/* Set the event bit in the receiver message bitmap */
-	atomic_or(&receiver->events, event);
+	deprecated_atomic_or(&receiver->events, event);
 
 	/* Re-schedule if priorities have changed */
 	if (in_interrupt_context()) {
 		/* The receiver might run again */
-		atomic_or(&tasks_ready, 1 << tskid);
+		deprecated_atomic_or(&tasks_ready, 1 << tskid);
 		if (start_called)
 			need_resched = 1;
 	} else {
@@ -463,7 +463,8 @@ uint32_t __ram_code task_wait_event_mask(uint32_t event_mask, int timeout_us)
 
 	/* Re-post any other events collected */
 	if (events & ~event_mask)
-		atomic_or(&current_task->events, events & ~event_mask);
+		deprecated_atomic_or(&current_task->events,
+				     events & ~event_mask);
 
 	return events & event_mask;
 }
@@ -493,12 +494,12 @@ void task_enable_all_tasks(void)
 
 void task_enable_task(task_id_t tskid)
 {
-	atomic_or(&tasks_enabled, BIT(tskid));
+	deprecated_atomic_or(&tasks_enabled, BIT(tskid));
 }
 
 void task_disable_task(task_id_t tskid)
 {
-	atomic_clear(&tasks_enabled, BIT(tskid));
+	deprecated_atomic_clear(&tasks_enabled, BIT(tskid));
 
 	if (!in_interrupt_context() && tskid == task_get_current())
 		__schedule(0, 0, 0);
@@ -557,7 +558,7 @@ void __ram_code mutex_lock(struct mutex *mtx)
 	uint32_t id = 1 << task_get_current();
 
 	ASSERT(id != TASK_ID_INVALID);
-	atomic_or(&mtx->waiters, id);
+	deprecated_atomic_or(&mtx->waiters, id);
 
 	while (1) {
 		asm volatile (
@@ -574,7 +575,7 @@ void __ram_code mutex_lock(struct mutex *mtx)
 		task_wait_event_mask(TASK_EVENT_MUTEX, 0);
 	}
 
-	atomic_clear(&mtx->waiters, id);
+	deprecated_atomic_clear(&mtx->waiters, id);
 }
 
 void __ram_code mutex_unlock(struct mutex *mtx)
@@ -598,7 +599,7 @@ void __ram_code mutex_unlock(struct mutex *mtx)
 	}
 
 	/* Ensure no event is remaining from mutex wake-up */
-	atomic_clear(&tsk->events, TASK_EVENT_MUTEX);
+	deprecated_atomic_clear(&tsk->events, TASK_EVENT_MUTEX);
 }
 
 void task_print_list(void)
diff --git a/driver/charger/sm5803.c b/driver/charger/sm5803.c
index fe501acd47..a7b7611d98 100644
--- a/driver/charger/sm5803.c
+++ b/driver/charger/sm5803.c
@@ -945,7 +945,7 @@ void sm5803_handle_interrupt(int chgnum)
 static void sm5803_irq_deferred(void)
 {
 	int i;
-	uint32_t pending = atomic_read_clear(&irq_pending);
+	uint32_t pending = deprecated_atomic_read_clear(&irq_pending);
 
 	for (i = 0; i < CHARGER_NUM; i++)
 		if (BIT(i) & pending)
@@ -955,7 +955,7 @@ DECLARE_DEFERRED(sm5803_irq_deferred);
 
 void sm5803_interrupt(int chgnum)
 {
-	atomic_or(&irq_pending, BIT(chgnum));
+	deprecated_atomic_or(&irq_pending, BIT(chgnum));
 	hook_call_deferred(&sm5803_irq_deferred_data, 0);
 }
 
diff --git a/driver/ppc/aoz1380.c b/driver/ppc/aoz1380.c
index 42239dd168..163c8db2ed 100644
--- a/driver/ppc/aoz1380.c
+++ b/driver/ppc/aoz1380.c
@@ -32,8 +32,9 @@ static uint32_t irq_pending; /* Bitmask of ports signaling an interrupt. */
 #define AOZ1380_FLAGS_INT_ON_DISCONNECT BIT(2)
 static uint32_t flags[CONFIG_USB_PD_PORT_MAX_COUNT];
 
-#define AOZ1380_SET_FLAG(port, flag) atomic_or(&flags[port], (flag))
-#define AOZ1380_CLR_FLAG(port, flag) atomic_clear(&flags[port], (flag))
+#define AOZ1380_SET_FLAG(port, flag) deprecated_atomic_or(&flags[port], (flag))
+#define AOZ1380_CLR_FLAG(port, flag) \
+	deprecated_atomic_clear(&flags[port], (flag))
 
 static int aoz1380_init(int port)
 {
@@ -143,7 +144,7 @@ static void aoz1380_handle_interrupt(int port)
 static void aoz1380_irq_deferred(void)
 {
 	int i;
-	uint32_t pending = atomic_read_clear(&irq_pending);
+	uint32_t pending = deprecated_atomic_read_clear(&irq_pending);
 
 	for (i = 0; i < board_get_usb_pd_port_count(); i++)
 		if (BIT(i) & pending)
@@ -153,7 +154,7 @@ DECLARE_DEFERRED(aoz1380_irq_deferred);
 
 void aoz1380_interrupt(int port)
 {
-	atomic_or(&irq_pending, BIT(port));
+	deprecated_atomic_or(&irq_pending, BIT(port));
 	hook_call_deferred(&aoz1380_irq_deferred_data, 0);
 }
 
diff --git a/driver/ppc/nx20p348x.c b/driver/ppc/nx20p348x.c
index 8142681bb4..c13087fa52 100644
--- a/driver/ppc/nx20p348x.c
+++ b/driver/ppc/nx20p348x.c
@@ -384,7 +384,7 @@ static void nx20p348x_handle_interrupt(int port)
 static void nx20p348x_irq_deferred(void)
 {
 	int i;
-	uint32_t pending = atomic_read_clear(&irq_pending);
+	uint32_t pending = deprecated_atomic_read_clear(&irq_pending);
 
 	for (i = 0; i < board_get_usb_pd_port_count(); i++)
 		if (BIT(i) & pending)
@@ -394,7 +394,7 @@ DECLARE_DEFERRED(nx20p348x_irq_deferred);
 
 void nx20p348x_interrupt(int port)
 {
-	atomic_or(&irq_pending, BIT(port));
+	deprecated_atomic_or(&irq_pending, BIT(port));
 	hook_call_deferred(&nx20p348x_irq_deferred_data, 0);
 }
 
diff --git a/driver/ppc/sn5s330.c b/driver/ppc/sn5s330.c
index f177efa10c..0de09ca60d 100644
--- a/driver/ppc/sn5s330.c
+++ b/driver/ppc/sn5s330.c
@@ -712,7 +712,7 @@ static void sn5s330_handle_interrupt(int port)
 static void sn5s330_irq_deferred(void)
 {
 	int i;
-	uint32_t pending = atomic_read_clear(&irq_pending);
+	uint32_t pending = deprecated_atomic_read_clear(&irq_pending);
 
 	for (i = 0; i < board_get_usb_pd_port_count(); i++)
 		if (BIT(i) & pending)
@@ -722,7 +722,7 @@ DECLARE_DEFERRED(sn5s330_irq_deferred);
 
 void sn5s330_interrupt(int port)
 {
-	atomic_or(&irq_pending, BIT(port));
+	deprecated_atomic_or(&irq_pending, BIT(port));
 	hook_call_deferred(&sn5s330_irq_deferred_data, 0);
 }
 
diff --git a/driver/ppc/syv682x.c b/driver/ppc/syv682x.c
index 0ea005051f..81a2034577 100644
--- a/driver/ppc/syv682x.c
+++ b/driver/ppc/syv682x.c
@@ -489,7 +489,7 @@ static void syv682x_handle_interrupt(int port)
 static void syv682x_irq_deferred(void)
 {
 	int i;
-	uint32_t pending = atomic_read_clear(&irq_pending);
+	uint32_t pending = deprecated_atomic_read_clear(&irq_pending);
 
 	for (i = 0; i < board_get_usb_pd_port_count(); i++)
 		if (BIT(i) & pending)
@@ -499,7 +499,7 @@ DECLARE_DEFERRED(syv682x_irq_deferred);
 
 static void syv682x_interrupt_delayed(int port, int delay)
 {
-	atomic_or(&irq_pending, BIT(port));
+	deprecated_atomic_or(&irq_pending, BIT(port));
 	hook_call_deferred(&syv682x_irq_deferred_data, delay * MSEC);
 }
 
diff --git a/driver/tcpm/tcpci.c b/driver/tcpm/tcpci.c
index 0c281f5ffd..5af5fe0151 100644
--- a/driver/tcpm/tcpci.c
+++ b/driver/tcpm/tcpci.c
@@ -883,7 +883,7 @@ int tcpm_enqueue_message(const int port)
 	}
 
 	/* Increment atomically to ensure get_message_raw happens-before */
-	atomic_add(&q->head, 1);
+	deprecated_atomic_add(&q->head, 1);
 
 	/* Wake PD task up so it can process incoming RX messages */
 	task_set_event(PD_PORT_TO_TASK_ID(port), TASK_EVENT_WAKE, 0);
@@ -915,7 +915,7 @@ int tcpm_dequeue_message(const int port, uint32_t *const payload,
 	memcpy(payload, tail->payload, sizeof(tail->payload));
 
 	/* Increment atomically to ensure memcpy happens-before */
-	atomic_add(&q->tail, 1);
+	deprecated_atomic_add(&q->tail, 1);
 
 	return EC_SUCCESS;
 }
diff --git a/include/system.h b/include/system.h
index dbdea7623b..34c3486f35 100644
--- a/include/system.h
+++ b/include/system.h
@@ -503,7 +503,7 @@ extern uint32_t sleep_mask;
  */
 static inline void enable_sleep(uint32_t mask)
 {
-	atomic_clear(&sleep_mask, mask);
+	deprecated_atomic_clear(&sleep_mask, mask);
 }
 
 /**
@@ -514,7 +514,7 @@ static inline void enable_sleep(uint32_t mask)
  */
 static inline void disable_sleep(uint32_t mask)
 {
-	atomic_or(&sleep_mask, mask);
+	deprecated_atomic_or(&sleep_mask, mask);
 }
 
 #ifdef CONFIG_LOW_POWER_IDLE_LIMITED
@@ -532,12 +532,12 @@ static inline uint32_t idle_is_disabled(void)
 
 static inline void disable_idle(void)
 {
-	atomic_or(&idle_disabled, 1);
+	deprecated_atomic_or(&idle_disabled, 1);
 }
 
 static inline void enable_idle(void)
 {
-	atomic_clear(&idle_disabled, 1);
+	deprecated_atomic_clear(&idle_disabled, 1);
 }
 #endif
 
diff --git a/test/stm32f_rtc.c b/test/stm32f_rtc.c
index fc1d0aaedb..7eb1930892 100644
--- a/test/stm32f_rtc.c
+++ b/test/stm32f_rtc.c
@@ -13,7 +13,7 @@ static const int rtc_delay_ms = 500;
 /* Override default RTC interrupt handler */
 void __rtc_alarm_irq(void)
 {
-	atomic_add(&rtc_fired, 1);
+	deprecated_atomic_add(&rtc_fired, 1);
 	reset_rtc_alarm(&rtc_irq);
 }
 
@@ -29,7 +29,7 @@ test_static int test_rtc_alarm(void)
 	msleep(2 * rtc_delay_ms);
 
 	/* Make sure the interrupt fired exactly once. */
-	TEST_EQ(1, atomic_read_clear(&rtc_fired), "%d");
+	TEST_EQ(1, deprecated_atomic_read_clear(&rtc_fired), "%d");
 
 	rtc_diff_us = get_rtc_diff(&rtc, &rtc_irq);