tree: Use new atomic_* implementation

It is done as a part of porting to Zephyr.
Since the implementation of atomic functions is done for all architectures
use atomic_* instead of deprecated_atomic_*.

Sometimes there was a compilation error "discards 'volatile' qualifier"
due to dropping "volatile" in the argument of the functions, thus
some pointers casts need to be made. It shouldn't cause any issues,
because we are sure about generated asm (store operation will be
performed).

BUG=b:169151160
BRANCH=none
TEST=buildall

Signed-off-by: Dawid Niedzwiecki <dn@semihalf.com>
Change-Id: I98f590c323c3af52035e62825e8acfa358e0805a
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/2478949
Tested-by: Jett Rink <jettrink@chromium.org>
Reviewed-by: Jett Rink <jettrink@chromium.org>
Reviewed-by: Tom Hughes <tomhughes@chromium.org>

18 files changed, 104 insertions, 126 deletions

diff --git a/common/button.c b/common/button.c
index 6f346ec7cb..a7908908b4 100644
--- a/common/button.c
+++ b/common/button.c
@@ -387,9 +387,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 */
-			deprecated_atomic_clear_bits(
-				&sim_button_state,
-				BIT(buttons[button_idx].type));
+			atomic_clear_bits(&sim_button_state,
+					  BIT(buttons[button_idx].type));
 
 			button_interrupt_simulate(button_idx);
 		}
@@ -405,8 +404,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 */
-			deprecated_atomic_or(&sim_button_state,
-					     BIT(buttons[button_idx].type));
+			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 bc82859e5d..e3c2f52620 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)
-		deprecated_atomic_or(&source_port_bitmap, 1 << port);
+		atomic_or((uint32_t *)&source_port_bitmap, 1 << port);
 	else
-		deprecated_atomic_clear_bits(&source_port_bitmap, 1 << port);
+		atomic_clear_bits((uint32_t *)&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 3b1fae79d0..ca13a58574 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 deprecated_atomic_read_clear(&device_current_events);
+	return 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);
 
-	deprecated_atomic_or(&device_current_events, mask);
+	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);
 
-	deprecated_atomic_clear_bits(&device_current_events, mask);
+	atomic_clear_bits(&device_current_events, mask);
 }
 
 static void device_set_enabled_events(uint32_t mask)
diff --git a/common/dptf.c b/common/dptf.c
index f4fc6d0ff6..2a2cef0c17 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? */
-			deprecated_atomic_clear_bits(&dptf_seen, BIT(id));
+			atomic_clear_bits(&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);
-			deprecated_atomic_or(&dptf_seen, BIT(sensor_id));
+			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);
-			deprecated_atomic_or(&dptf_seen, BIT(sensor_id));
+			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;
-		deprecated_atomic_clear_bits(&dptf_seen, BIT(sensor_id));
+		atomic_clear_bits(&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 5611fd828d..2965b52fe9 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)
 {
-	deprecated_atomic_or(&fp_events, event);
+	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 = deprecated_atomic_read_clear(&fp_events);
+		event = 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 = deprecated_atomic_read_clear(&fp_events);
+	uint32_t event = 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);
 
-	deprecated_atomic_read_clear(&fp_events);
+	atomic_read_clear(&fp_events);
 
 	return rc;
 }
diff --git a/common/fpsensor/fpsensor_state.c b/common/fpsensor/fpsensor_state.c
index 82fa4f23a1..ec4ddb4fd9 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 = deprecated_atomic_read_clear(&fp_events);
+	uint32_t event_out = 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 9ab7f19d04..665a268ec4 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;
 
-	deprecated_atomic_or(ptr, (uint32_t)m);
+	atomic_or(ptr, (uint32_t)m);
 #ifdef CONFIG_HOST_EVENT64
-	deprecated_atomic_or(ptr + 1, (uint32_t)(m >> 32));
+	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;
 
-	deprecated_atomic_clear_bits(ptr, (uint32_t)m);
+	atomic_clear_bits(ptr, (uint32_t)m);
 #ifdef CONFIG_HOST_EVENT64
-	deprecated_atomic_clear_bits(ptr + 1, (uint32_t)(m >> 32));
+	atomic_clear_bits(ptr + 1, (uint32_t)(m >> 32));
 #endif
 }
 
diff --git a/common/keyboard_mkbp.c b/common/keyboard_mkbp.c
index 9b41ef593e..45cd50f4f5 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;
-	deprecated_atomic_sub(&fifo_entries, 1);
+	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;
-	deprecated_atomic_add(&fifo_entries, 1);
+	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 0e95eb6c34..eae7f90118 100644
--- a/common/keyboard_scan.c
+++ b/common/keyboard_scan.c
@@ -143,10 +143,9 @@ void keyboard_scan_enable(int enable, enum kb_scan_disable_masks mask)
 {
 	/* Access atomically */
 	if (enable) {
-		deprecated_atomic_clear_bits((uint32_t *)&disable_scanning_mask,
-					     mask);
+		atomic_clear_bits((uint32_t *)&disable_scanning_mask, mask);
 	} else {
-		deprecated_atomic_or((uint32_t *)&disable_scanning_mask, mask);
+		atomic_or((uint32_t *)&disable_scanning_mask, mask);
 		clear_typematic_key();
 	}
 
diff --git a/common/motion_sense.c b/common/motion_sense.c
index a283ce7346..6feed6738d 100644
--- a/common/motion_sense.c
+++ b/common/motion_sense.c
@@ -677,12 +677,11 @@ 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 =
-			deprecated_atomic_read_clear(&odr_event_required);
+		int odr_pending = atomic_read_clear(&odr_event_required);
 
 		is_odr_pending = odr_pending & sensor_bit;
 		odr_pending &= ~sensor_bit;
-		deprecated_atomic_or(&odr_event_required, odr_pending);
+		atomic_or(&odr_event_required, odr_pending);
 	}
 
 #ifdef CONFIG_ACCEL_INTERRUPTS
@@ -708,8 +707,7 @@ 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 =
-			deprecated_atomic_read_clear(&sensor->flush_pending);
+		int flush_pending = atomic_read_clear(&sensor->flush_pending);
 
 		for (; flush_pending > 0; flush_pending--) {
 			motion_sense_fifo_insert_async_event(
@@ -1172,8 +1170,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.
 			 */
-			deprecated_atomic_or(&odr_event_required,
-					     1 << (sensor - motion_sensors));
+			atomic_or(&odr_event_required,
+				  1 << (sensor - motion_sensors));
 			task_set_event(TASK_ID_MOTIONSENSE,
 					TASK_EVENT_MOTION_ODR_CHANGE, 0);
 		}
@@ -1294,7 +1292,7 @@ static enum ec_status host_cmd_motion_sense(struct host_cmd_handler_args *args)
 		if (sensor == NULL)
 			return EC_RES_INVALID_PARAM;
 
-		deprecated_atomic_add(&sensor->flush_pending, 1);
+		atomic_add(&sensor->flush_pending, 1);
 
 		task_set_event(TASK_ID_MOTIONSENSE,
 			       TASK_EVENT_MOTION_FLUSH_PENDING, 0);
@@ -1645,8 +1643,7 @@ static int command_accel_data_rate(int argc, char **argv)
 		sensor->config[config_id].odr =
 			data | (round ? ROUND_UP_FLAG : 0);
 
-		deprecated_atomic_or(&odr_event_required,
-				     1 << (sensor - motion_sensors));
+		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 c359efb541..7b6cd0b5f5 100644
--- a/common/timer.c
+++ b/common/timer.c
@@ -41,7 +41,7 @@ static int timer_irq;
 static void expire_timer(task_id_t tskid)
 {
 	/* we are done with this timer */
-	deprecated_atomic_clear_bits(&timer_running, 1 << tskid);
+	atomic_clear_bits(&timer_running, 1 << tskid);
 	/* wake up the taks waiting for this timer */
 	task_set_event(tskid, TASK_EVENT_TIMER, 0);
 }
@@ -132,7 +132,7 @@ int timer_arm(timestamp_t event, task_id_t tskid)
 		return EC_ERROR_BUSY;
 
 	timer_deadline[tskid] = event;
-	deprecated_atomic_or(&timer_running, BIT(tskid));
+	atomic_or(&timer_running, BIT(tskid));
 
 	/* Modify the next event if needed */
 	if ((event.le.hi < now.le.hi) ||
@@ -146,7 +146,7 @@ void timer_cancel(task_id_t tskid)
 {
 	ASSERT(tskid < TASK_ID_COUNT);
 
-	deprecated_atomic_clear_bits(&timer_running, BIT(tskid));
+	atomic_clear_bits(&timer_running, BIT(tskid));
 	/*
 	 * Don't need to cancel the hardware timer interrupt, instead do
 	 * timer-related housekeeping when the next timer interrupt fires.
@@ -186,8 +186,8 @@ void usleep(unsigned us)
 
 	/* Re-queue other events which happened in the meanwhile */
 	if (evt)
-		deprecated_atomic_or(task_get_event_bitmap(task_get_current()),
-				     evt & ~TASK_EVENT_TIMER);
+		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 d2a5e43cdb..7053607433 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 = deprecated_atomic_read_clear(&port_oc_reset_req);
+	uint32_t ports = 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. */
-	deprecated_atomic_or(&port_oc_reset_req, BIT(port));
+	atomic_or(&port_oc_reset_req, BIT(port));
 	hook_call_deferred(&re_enable_ports_data, SECOND);
 }
 
@@ -747,8 +747,7 @@ static uint32_t pd_ports_to_resume;
 static void resume_pd_port(void)
 {
 	uint32_t port;
-	uint32_t suspended_ports =
-		deprecated_atomic_read_clear(&pd_ports_to_resume);
+	uint32_t suspended_ports = atomic_read_clear(&pd_ports_to_resume);
 
 	while (suspended_ports) {
 		port = __builtin_ctz(suspended_ports);
@@ -760,7 +759,7 @@ DECLARE_DEFERRED(resume_pd_port);
 
 void pd_deferred_resume(int port)
 {
-	deprecated_atomic_or(&pd_ports_to_resume, 1 << port);
+	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 8bdc50a0e3..19e74b47aa 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 deprecated_atomic_ functions which use assembly to access them.
+ * address to 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 = deprecated_atomic_read_clear(&pd_host_event_status);
+	r->status = 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;
 
-	deprecated_atomic_or(&pd_host_event_status, mask);
+	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 fe125aa5db..be17b187e8 100644
--- a/common/usb_pd_protocol.c
+++ b/common/usb_pd_protocol.c
@@ -531,11 +531,10 @@ 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.
 	 */
-	deprecated_atomic_clear_bits(task_get_event_bitmap(task_get_current()),
-				     PD_EVENT_TCPC_RESET);
+	atomic_clear_bits(task_get_event_bitmap(task_get_current()),
+			  PD_EVENT_TCPC_RESET);
 
-	waiting_tasks =
-		deprecated_atomic_read_clear(&pd[port].tasks_waiting_on_reset);
+	waiting_tasks = atomic_read_clear(&pd[port].tasks_waiting_on_reset);
 
 	/*
 	 * Now that we are done waking up the device, handle device access
@@ -563,8 +562,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 */
-		deprecated_atomic_or(&pd[port].tasks_waiting_on_reset,
-				     1 << task_get_current());
+		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,
@@ -608,11 +607,10 @@ void pd_prevent_low_power_mode(int port, int prevent)
 	const int current_task_mask = (1 << task_get_current());
 
 	if (prevent)
-		deprecated_atomic_or(&pd[port].tasks_preventing_lpm,
-				     current_task_mask);
+		atomic_or(&pd[port].tasks_preventing_lpm, current_task_mask);
 	else
-		deprecated_atomic_clear_bits(&pd[port].tasks_preventing_lpm,
-					     current_task_mask);
+		atomic_clear_bits(&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 655bae4599..123cd07a81 100644
--- a/common/usbc/usb_pe_drp_sm.c
+++ b/common/usbc/usb_pe_drp_sm.c
@@ -63,20 +63,17 @@
 #define CPRINTS_L2(format, args...) CPRINTS_LX(2, format, ## args)
 #define CPRINTS_L3(format, args...) CPRINTS_LX(3, format, ## args)
 
-
-#define PE_SET_FLAG(port, flag) deprecated_atomic_or(&pe[port].flags, (flag))
-#define PE_CLR_FLAG(port, flag) \
-	deprecated_atomic_clear_bits(&pe[port].flags, (flag))
+#define PE_SET_FLAG(port, flag) atomic_or(&pe[port].flags, (flag))
+#define PE_CLR_FLAG(port, flag) atomic_clear_bits(&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) \
-	deprecated_atomic_or(&pe[port].dpm_request, (req))
+#define PE_SET_DPM_REQUEST(port, req) atomic_or(&pe[port].dpm_request, (req))
 #define PE_CLR_DPM_REQUEST(port, req) \
-	deprecated_atomic_clear_bits(&pe[port].dpm_request, (req))
+	atomic_clear_bits(&pe[port].dpm_request, (req))
 #define PE_CHK_DPM_REQUEST(port, req) (pe[port].dpm_request & (req))
 
 /*
@@ -1029,7 +1026,7 @@ void pe_notify_event(int port, uint32_t event_mask)
 	/* Events may only be set from the PD task */
 	assert(port == TASK_ID_TO_PD_PORT(task_get_current()));
 
-	deprecated_atomic_or(&pe[port].events, event_mask);
+	atomic_or(&pe[port].events, event_mask);
 
 	/* Notify the host that new events are available to read */
 	pd_send_host_event(PD_EVENT_TYPEC);
@@ -1037,7 +1034,7 @@ void pe_notify_event(int port, uint32_t event_mask)
 
 void pd_clear_events(int port, uint32_t clear_mask)
 {
-	deprecated_atomic_clear_bits(&pe[port].events, clear_mask);
+	atomic_clear_bits(&pe[port].events, clear_mask);
 }
 
 uint32_t pd_get_events(int port)
@@ -6193,10 +6190,9 @@ void pd_dfp_discovery_init(int port)
 	PE_CLR_FLAG(port, PE_FLAGS_VDM_SETUP_DONE |
 			  PE_FLAGS_MODAL_OPERATION);
 
-	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()));
+	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()));
 
 	memset(pe[port].discovery, 0, sizeof(pe[port].discovery));
 	memset(pe[port].partner_amodes, 0, sizeof(pe[port].partner_amodes));
@@ -6216,7 +6212,7 @@ void pd_dfp_discovery_init(int port)
 
 void pd_discovery_access_clear(int port, enum tcpm_transmit_type type)
 {
-	deprecated_atomic_clear_bits(&task_access[port][type], 0xFFFFFFFF);
+	atomic_clear_bits(&task_access[port][type], 0xFFFFFFFF);
 }
 
 bool pd_discovery_access_validate(int port, enum tcpm_transmit_type type)
@@ -6228,7 +6224,7 @@ struct pd_discovery *pd_get_am_discovery(int port, enum tcpm_transmit_type type)
 {
 	ASSERT(type < DISCOVERY_TYPE_COUNT);
 
-	deprecated_atomic_or(&task_access[port][type], BIT(task_get_current()));
+	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 69861fb482..4817d4e76f 100644
--- a/common/usbc/usb_prl_sm.c
+++ b/common/usbc/usb_prl_sm.c
@@ -40,32 +40,26 @@
 #define CPRINTS(format, args...)
 #endif
 
-#define RCH_SET_FLAG(port, flag) deprecated_atomic_or(&rch[port].flags, (flag))
-#define RCH_CLR_FLAG(port, flag) \
-	deprecated_atomic_clear_bits(&rch[port].flags, (flag))
+#define RCH_SET_FLAG(port, flag) atomic_or(&rch[port].flags, (flag))
+#define RCH_CLR_FLAG(port, flag) atomic_clear_bits(&rch[port].flags, (flag))
 #define RCH_CHK_FLAG(port, flag) (rch[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_bits(&tch[port].flags, (flag))
+#define TCH_SET_FLAG(port, flag) atomic_or(&tch[port].flags, (flag))
+#define TCH_CLR_FLAG(port, flag) atomic_clear_bits(&tch[port].flags, (flag))
 #define TCH_CHK_FLAG(port, flag) (tch[port].flags & (flag))
 
-#define PRL_TX_SET_FLAG(port, flag) \
-	deprecated_atomic_or(&prl_tx[port].flags, (flag))
+#define PRL_TX_SET_FLAG(port, flag) atomic_or(&prl_tx[port].flags, (flag))
 #define PRL_TX_CLR_FLAG(port, flag) \
-	deprecated_atomic_clear_bits(&prl_tx[port].flags, (flag))
+	atomic_clear_bits(&prl_tx[port].flags, (flag))
 #define PRL_TX_CHK_FLAG(port, flag) (prl_tx[port].flags & (flag))
 
-#define PRL_HR_SET_FLAG(port, flag) \
-	deprecated_atomic_or(&prl_hr[port].flags, (flag))
+#define PRL_HR_SET_FLAG(port, flag) atomic_or(&prl_hr[port].flags, (flag))
 #define PRL_HR_CLR_FLAG(port, flag) \
-	deprecated_atomic_clear_bits(&prl_hr[port].flags, (flag))
+	atomic_clear_bits(&prl_hr[port].flags, (flag))
 #define PRL_HR_CHK_FLAG(port, flag) (prl_hr[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_bits(&pdmsg[port].flags, (flag))
+#define PDMSG_SET_FLAG(port, flag) atomic_or(&pdmsg[port].flags, (flag))
+#define PDMSG_CLR_FLAG(port, flag) atomic_clear_bits(&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 3382c3b84c..5a0d6ed3fd 100644
--- a/common/usbc/usb_tc_drp_acc_trysrc_sm.c
+++ b/common/usbc/usb_tc_drp_acc_trysrc_sm.c
@@ -60,20 +60,19 @@
 
 #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);                           \
-		deprecated_atomic_or(&tc[port].flags, (flag)); \
+#define TC_SET_FLAG(port, flag)                     \
+	do {                                        \
+		print_flag(1, flag);                \
+		atomic_or(&tc[port].flags, (flag)); \
 	} while (0)
-#define TC_CLR_FLAG(port, flag)                                        \
-	do {                                                           \
-		print_flag(0, flag);                                   \
-		deprecated_atomic_clear_bits(&tc[port].flags, (flag)); \
+#define TC_CLR_FLAG(port, flag)                             \
+	do {                                                \
+		print_flag(0, flag);                        \
+		atomic_clear_bits(&tc[port].flags, (flag)); \
 	} while (0)
 #else
-#define TC_SET_FLAG(port, flag) deprecated_atomic_or(&tc[port].flags, (flag))
-#define TC_CLR_FLAG(port, flag) \
-	deprecated_atomic_clear_bits(&tc[port].flags, (flag))
+#define TC_SET_FLAG(port, flag) atomic_or(&tc[port].flags, (flag))
+#define TC_CLR_FLAG(port, flag) atomic_clear_bits(&tc[port].flags, (flag))
 #endif
 #define TC_CHK_FLAG(port, flag) (tc[port].flags & (flag))
 
@@ -632,11 +631,10 @@ static bool pd_comm_allowed_by_policy(void)
 static void tc_policy_pd_enable(int port, int en)
 {
 	if (en)
-		deprecated_atomic_clear_bits(&tc[port].pd_disabled_mask,
-					     PD_DISABLED_BY_POLICY);
+		atomic_clear_bits(&tc[port].pd_disabled_mask,
+				  PD_DISABLED_BY_POLICY);
 	else
-		deprecated_atomic_or(&tc[port].pd_disabled_mask,
-				     PD_DISABLED_BY_POLICY);
+		atomic_or(&tc[port].pd_disabled_mask, PD_DISABLED_BY_POLICY);
 
 	CPRINTS("C%d: PD comm policy %sabled", port, en ? "en" : "dis");
 }
@@ -644,20 +642,20 @@ static void tc_policy_pd_enable(int port, int en)
 static void tc_enable_pd(int port, int en)
 {
 	if (en)
-		deprecated_atomic_clear_bits(&tc[port].pd_disabled_mask,
-					     PD_DISABLED_NO_CONNECTION);
+		atomic_clear_bits(&tc[port].pd_disabled_mask,
+				  PD_DISABLED_NO_CONNECTION);
 	else
-		deprecated_atomic_or(&tc[port].pd_disabled_mask,
-				     PD_DISABLED_NO_CONNECTION);
+		atomic_or(&tc[port].pd_disabled_mask,
+			  PD_DISABLED_NO_CONNECTION);
 }
 
 #ifdef CONFIG_USB_PD_TRY_SRC
 static void tc_enable_try_src(int en)
 {
 	if (en)
-		deprecated_atomic_or(&pd_try_src, 1);
+		atomic_or(&pd_try_src, 1);
 	else
-		deprecated_atomic_clear_bits(&pd_try_src, 1);
+		atomic_clear_bits(&pd_try_src, 1);
 }
 #endif
 
@@ -1777,11 +1775,10 @@ 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.
 	 */
-	deprecated_atomic_clear_bits(task_get_event_bitmap(task_get_current()),
-				     PD_EVENT_TCPC_RESET);
+	atomic_clear_bits(task_get_event_bitmap(task_get_current()),
+			  PD_EVENT_TCPC_RESET);
 
-	waiting_tasks =
-		deprecated_atomic_read_clear(&tc[port].tasks_waiting_on_reset);
+	waiting_tasks = atomic_read_clear(&tc[port].tasks_waiting_on_reset);
 
 	/* Wake up all waiting tasks. */
 	while (waiting_tasks) {
@@ -1804,8 +1801,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 */
-		deprecated_atomic_or(&tc[port].tasks_waiting_on_reset,
-				     1 << task_get_current());
+		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,
@@ -1845,11 +1842,10 @@ void pd_prevent_low_power_mode(int port, int prevent)
 		return;
 
 	if (prevent)
-		deprecated_atomic_or(&tc[port].tasks_preventing_lpm,
-				     current_task_mask);
+		atomic_or(&tc[port].tasks_preventing_lpm, current_task_mask);
 	else
-		deprecated_atomic_clear_bits(&tc[port].tasks_preventing_lpm,
-					     current_task_mask);
+		atomic_clear_bits(&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 6724d75abf..73dbf9d1c0 100644
--- a/common/usbc_ppc.c
+++ b/common/usbc_ppc.c
@@ -84,7 +84,7 @@ int ppc_add_oc_event(int port)
 	oc_event_cnt_tbl[port]++;
 
 	/* The port overcurrented, so don't clear it's OC events. */
-	deprecated_atomic_clear_bits(&snk_connected_ports, 1 << port);
+	atomic_clear_bits(&snk_connected_ports, 1 << port);
 
 	if (oc_event_cnt_tbl[port] >= PPC_OC_CNT_THRESH)
 		ppc_prints("OC event limit reached! "
@@ -269,10 +269,10 @@ int ppc_dev_is_connected(int port, enum ppc_device_role dev)
 	}
 
 	if (dev == PPC_DEV_SNK)
-		deprecated_atomic_or(&snk_connected_ports, 1 << port);
+		atomic_or(&snk_connected_ports, 1 << port);
 	else
 		/* clear flag if it transitions to SRC or disconnected */
-		deprecated_atomic_clear_bits(&snk_connected_ports, 1 << port);
+		atomic_clear_bits(&snk_connected_ports, 1 << port);
 
 	ppc = &ppc_chips[port];
 	if (ppc->drv->dev_is_connected)