diff options
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(¤t_task->events, events & ~event_mask); + deprecated_atomic_or(¤t_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(¤t_task->events, events & ~event_mask); + deprecated_atomic_or(¤t_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(¤t_task->events, events & ~event_mask); + deprecated_atomic_or(¤t_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(¤t_task->events, events & ~event_mask); + deprecated_atomic_or(¤t_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(¤t_task->events, events & ~event_mask); + deprecated_atomic_or(¤t_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); |