task_set_event: remove the wait argument

There is an option in the task_set_event function which force
the calling task to wait for an event. However, the option is never
used thus remove it.

This also will help in the Zephyr migration process.

BUG=b:172360521
BRANCH=none
TEST=make buildall

Signed-off-by: Dawid Niedzwiecki <dn@semihalf.com>
Change-Id: Ic152fd3d6862d487bcc0024c48d136556c0b81bc
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/ec/+/2521599
Reviewed-by: Jett Rink <jettrink@chromium.org>
Reviewed-by: Tom Hughes <tomhughes@chromium.org>
Reviewed-by: Jack Rosenthal <jrosenth@chromium.org>
Commit-Queue: Jack Rosenthal <jrosenth@chromium.org>

17 files changed, 43 insertions, 49 deletions

diff --git a/common/fpsensor/fpsensor.c b/common/fpsensor/fpsensor.c
index 6b782845f2..08a456dc0e 100644
--- a/common/fpsensor/fpsensor.c
+++ b/common/fpsensor/fpsensor.c
@@ -63,7 +63,7 @@ BUILD_ASSERT(sizeof(struct ec_fp_template_encryption_metadata) % 4 == 0);
 /* Interrupt line from the fingerprint sensor */
 void fps_event(enum gpio_signal signal)
 {
-	task_set_event(TASK_ID_FPSENSOR, TASK_EVENT_SENSOR_IRQ, 0);
+	task_set_event(TASK_ID_FPSENSOR, TASK_EVENT_SENSOR_IRQ);
 }
 
 static void send_mkbp_event(uint32_t event)
@@ -793,12 +793,12 @@ int command_fpenroll(int argc, char **argv)
 			enroll_str[EC_MKBP_FP_ERRCODE(event) & 3], percent);
 		/* wait for finger release between captures */
 		sensor_mode = FP_MODE_ENROLL_SESSION | FP_MODE_FINGER_UP;
-		task_set_event(TASK_ID_FPSENSOR, TASK_EVENT_UPDATE_CONFIG, 0);
+		task_set_event(TASK_ID_FPSENSOR, TASK_EVENT_UPDATE_CONFIG);
 		while (tries-- && sensor_mode & FP_MODE_FINGER_UP)
 			usleep(20 * MSEC);
 	} while (percent < 100);
 	sensor_mode = 0; /* reset FP_MODE_ENROLL_SESSION */
-	task_set_event(TASK_ID_FPSENSOR, TASK_EVENT_UPDATE_CONFIG, 0);
+	task_set_event(TASK_ID_FPSENSOR, TASK_EVENT_UPDATE_CONFIG);
 
 	return rc;
 }
diff --git a/common/fpsensor/fpsensor_state.c b/common/fpsensor/fpsensor_state.c
index 70568d8ec4..db64110b56 100644
--- a/common/fpsensor/fpsensor_state.c
+++ b/common/fpsensor/fpsensor_state.c
@@ -192,7 +192,7 @@ int fp_set_sensor_mode(uint32_t mode, uint32_t *mode_output)
 
 	if (!(mode & FP_MODE_DONT_CHANGE)) {
 		sensor_mode = mode;
-		task_set_event(TASK_ID_FPSENSOR, TASK_EVENT_UPDATE_CONFIG, 0);
+		task_set_event(TASK_ID_FPSENSOR, TASK_EVENT_UPDATE_CONFIG);
 	}
 
 	*mode_output = sensor_mode;
diff --git a/common/host_command.c b/common/host_command.c
index c5821df6d3..2c38b45f1e 100644
--- a/common/host_command.c
+++ b/common/host_command.c
@@ -179,7 +179,7 @@ void host_command_received(struct host_cmd_handler_args *args)
 		pending_args = args;
 
 		/* Wake up the task to handle the command */
-		task_set_event(TASK_ID_HOSTCMD, TASK_EVENT_CMD_PENDING, 0);
+		task_set_event(TASK_ID_HOSTCMD, TASK_EVENT_CMD_PENDING);
 		return;
 	}
 
diff --git a/common/host_command_pd.c b/common/host_command_pd.c
index 869cad4493..d46220a7a6 100644
--- a/common/host_command_pd.c
+++ b/common/host_command_pd.c
@@ -51,12 +51,12 @@ void host_command_pd_send_status(enum pd_charge_state new_chg_state)
 		charge_state = new_chg_state;
 #endif
 	/* Wake PD HC task to send status */
-	task_set_event(TASK_ID_PDCMD, TASK_EVENT_EXCHANGE_PD_STATUS, 0);
+	task_set_event(TASK_ID_PDCMD, TASK_EVENT_EXCHANGE_PD_STATUS);
 }
 
 void host_command_pd_request_hibernate(void)
 {
-	task_set_event(TASK_ID_PDCMD, TASK_EVENT_HIBERNATING, 0);
+	task_set_event(TASK_ID_PDCMD, TASK_EVENT_HIBERNATING);
 }
 
 #ifdef CONFIG_HOSTCMD_PD
diff --git a/common/lightbar.c b/common/lightbar.c
index 03b6fe5ca1..f80287941d 100644
--- a/common/lightbar.c
+++ b/common/lightbar.c
@@ -1658,7 +1658,7 @@ void lightbar_sequence_f(enum lightbar_sequence num, const char *f)
 		CPRINTS("LB %s() requests %d %s", f, num,
 			lightbar_cmds[num].string);
 		pending_msg = num;
-		task_set_event(TASK_ID_LIGHTBAR, PENDING_MSG, 0);
+		task_set_event(TASK_ID_LIGHTBAR, PENDING_MSG);
 	} else
 		CPRINTS("LB %s() requests %d - ignored", f, num);
 }
diff --git a/common/motion_sense.c b/common/motion_sense.c
index d4e1cbdc10..7a306bfb4a 100644
--- a/common/motion_sense.c
+++ b/common/motion_sense.c
@@ -419,7 +419,7 @@ static void motion_sense_switch_sensor_rate(void)
 	if (sensor_setup_mask) {
 		atomic_or(&odr_event_required, sensor_setup_mask);
 		task_set_event(TASK_ID_MOTIONSENSE,
-			       TASK_EVENT_MOTION_ODR_CHANGE, 0);
+			       TASK_EVENT_MOTION_ODR_CHANGE);
 	} else {
 		/* No sensor activated, reset host interval interval to 0. */
 		ap_event_interval = 0;
@@ -1130,7 +1130,7 @@ static enum ec_status host_cmd_motion_sense(struct host_cmd_handler_args *args)
 
 			/* Force a collection to purge old events.  */
 			task_set_event(TASK_ID_MOTIONSENSE,
-					TASK_EVENT_MOTION_ODR_CHANGE, 0);
+				       TASK_EVENT_MOTION_ODR_CHANGE);
 		}
 
 		out->ec_rate.ret = motion_sense_ec_rate(sensor) / MSEC;
@@ -1158,7 +1158,7 @@ static enum ec_status host_cmd_motion_sense(struct host_cmd_handler_args *args)
 			atomic_or(&odr_event_required,
 				  BIT(sensor - motion_sensors));
 			task_set_event(TASK_ID_MOTIONSENSE,
-					TASK_EVENT_MOTION_ODR_CHANGE, 0);
+				       TASK_EVENT_MOTION_ODR_CHANGE);
 		}
 
 		out->sensor_odr.ret = sensor->drv->get_data_rate(sensor);
@@ -1277,7 +1277,7 @@ static enum ec_status host_cmd_motion_sense(struct host_cmd_handler_args *args)
 		atomic_add(&sensor->flush_pending, 1);
 
 		task_set_event(TASK_ID_MOTIONSENSE,
-			       TASK_EVENT_MOTION_FLUSH_PENDING, 0);
+			       TASK_EVENT_MOTION_FLUSH_PENDING);
 		/* pass-through */
 	case MOTIONSENSE_CMD_FIFO_INFO:
 		if (!IS_ENABLED(CONFIG_ACCEL_FIFO)) {
@@ -1671,7 +1671,7 @@ static int command_accel_data_rate(int argc, char **argv)
 
 		atomic_or(&odr_event_required, 1 << (sensor - motion_sensors));
 		task_set_event(TASK_ID_MOTIONSENSE,
-				TASK_EVENT_MOTION_ODR_CHANGE, 0);
+			       TASK_EVENT_MOTION_ODR_CHANGE);
 	} else {
 		ccprintf("Data rate for sensor %d: %d\n", id,
 			 sensor->drv->get_data_rate(sensor));
diff --git a/common/rwsig.c b/common/rwsig.c
index e23ca23293..4ed356f472 100644
--- a/common/rwsig.c
+++ b/common/rwsig.c
@@ -254,12 +254,12 @@ enum rwsig_status rwsig_get_status(void)
 
 void rwsig_abort(void)
 {
-	task_set_event(TASK_ID_RWSIG, TASK_EVENT_ABORT, 0);
+	task_set_event(TASK_ID_RWSIG, TASK_EVENT_ABORT);
 }
 
 void rwsig_continue(void)
 {
-	task_set_event(TASK_ID_RWSIG, TASK_EVENT_CONTINUE, 0);
+	task_set_event(TASK_ID_RWSIG, TASK_EVENT_CONTINUE);
 }
 
 void rwsig_task(void *u)
diff --git a/common/timer.c b/common/timer.c
index 7b6cd0b5f5..d0386a9eca 100644
--- a/common/timer.c
+++ b/common/timer.c
@@ -43,7 +43,7 @@ static void expire_timer(task_id_t tskid)
 	/* we are done with this timer */
 	atomic_clear_bits(&timer_running, 1 << tskid);
 	/* wake up the taks waiting for this timer */
-	task_set_event(tskid, TASK_EVENT_TIMER, 0);
+	task_set_event(tskid, TASK_EVENT_TIMER);
 }
 
 int timestamp_expired(timestamp_t deadline, const timestamp_t *now)
diff --git a/common/usb_charger.c b/common/usb_charger.c
index a8396b47bd..5b14608021 100644
--- a/common/usb_charger.c
+++ b/common/usb_charger.c
@@ -72,7 +72,7 @@ void usb_charger_vbus_change(int port, int vbus_level)
 
 #ifdef HAS_TASK_USB_CHG_P0
 	/* USB Charger task(s) */
-	task_set_event(USB_CHG_PORT_TO_TASK_ID(port), USB_CHG_EVENT_VBUS, 0);
+	task_set_event(USB_CHG_PORT_TO_TASK_ID(port), USB_CHG_EVENT_VBUS);
 #endif
 
 #if (defined(CONFIG_USB_PD_VBUS_DETECT_CHARGER) \
diff --git a/common/usb_common.c b/common/usb_common.c
index 1b068ba8af..3011189ca7 100644
--- a/common/usb_common.c
+++ b/common/usb_common.c
@@ -461,7 +461,7 @@ void usb_mux_set_safe_mode(int port)
 
 static void pd_send_hard_reset(int port)
 {
-	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_SEND_HARD_RESET, 0);
+	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_SEND_HARD_RESET);
 }
 
 #ifdef CONFIG_USBC_OCP
diff --git a/common/usb_pd_alt_mode_dfp.c b/common/usb_pd_alt_mode_dfp.c
index 1c1801ff75..b0347067ce 100644
--- a/common/usb_pd_alt_mode_dfp.c
+++ b/common/usb_pd_alt_mode_dfp.c
@@ -149,7 +149,7 @@ void pd_prepare_sysjump(void)
 			continue;
 
 		sysjump_task_waiting = task_get_current();
-		task_set_event(PD_PORT_TO_TASK_ID(i), PD_EVENT_SYSJUMP, 0);
+		task_set_event(PD_PORT_TO_TASK_ID(i), PD_EVENT_SYSJUMP);
 		task_wait_event_mask(TASK_EVENT_SYSJUMP_READY, -1);
 		sysjump_task_waiting = TASK_ID_INVALID;
 	}
@@ -653,8 +653,7 @@ void notify_sysjump_ready(void)
 	 * task waiting on us to complete.
 	 */
 	if (sysjump_task_waiting != TASK_ID_INVALID)
-		task_set_event(sysjump_task_waiting,
-				TASK_EVENT_SYSJUMP_READY, 0);
+		task_set_event(sysjump_task_waiting, TASK_EVENT_SYSJUMP_READY);
 }
 
 static inline bool is_rev3_vdo(int port, enum tcpm_transmit_type type)
diff --git a/common/usb_pd_protocol.c b/common/usb_pd_protocol.c
index 8115d9d5a6..4fae35aedb 100644
--- a/common/usb_pd_protocol.c
+++ b/common/usb_pd_protocol.c
@@ -541,7 +541,7 @@ static int reset_device_and_notify(int port)
 	while (waiting_tasks) {
 		task = __fls(waiting_tasks);
 		waiting_tasks &= ~BIT(task);
-		task_set_event(task, TASK_EVENT_PD_AWAKE, 0);
+		task_set_event(task, TASK_EVENT_PD_AWAKE);
 	}
 
 	return rv;
@@ -564,8 +564,7 @@ static void pd_wait_for_wakeup(int port)
 		 * happen much, but it if starts occurring, we can add a guard
 		 * to prevent/reduce it.
 		 */
-		task_set_event(PD_PORT_TO_TASK_ID(port),
-			       PD_EVENT_TCPC_RESET, 0);
+		task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_TCPC_RESET);
 		task_wait_event_mask(TASK_EVENT_PD_AWAKE, -1);
 	}
 }
@@ -590,7 +589,7 @@ void pd_device_accessed(int port)
 		handle_device_access(port);
 	} else {
 		task_set_event(PD_PORT_TO_TASK_ID(port),
-			       PD_EVENT_DEVICE_ACCESSED, 0);
+			       PD_EVENT_DEVICE_ACCESSED);
 	}
 }
 
@@ -793,7 +792,7 @@ static inline void set_state(int port, enum pd_states next_state)
 		 * down.
 		 */
 		task_set_event(USB_CHG_PORT_TO_TASK_ID(port),
-			       USB_CHG_EVENT_CC_OPEN, 0);
+			       USB_CHG_EVENT_CC_OPEN);
 #endif /* CONFIG_BC12_DETECT_DATA_ROLE_TRIGGER */
 #ifdef CONFIG_USBC_VCONN
 		set_vconn(port, 0);
@@ -891,7 +890,7 @@ void pd_transmit_complete(int port, int status)
 		inc_id(port);
 
 	pd[port].tx_status = status;
-	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_TX, 0);
+	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_TX);
 }
 
 static int pd_transmit(int port, enum tcpm_transmit_type type,
@@ -1326,10 +1325,10 @@ static void pd_set_data_role(int port, enum pd_data_role role)
 	 */
 	if (role == PD_ROLE_UFP)
 		task_set_event(USB_CHG_PORT_TO_TASK_ID(port),
-			       USB_CHG_EVENT_DR_UFP, 0);
+			       USB_CHG_EVENT_DR_UFP);
 	else if (role == PD_ROLE_DFP)
 		task_set_event(USB_CHG_PORT_TO_TASK_ID(port),
-			       USB_CHG_EVENT_DR_DFP, 0);
+			       USB_CHG_EVENT_DR_DFP);
 #endif /* CONFIG_BC12_DETECT_DATA_ROLE_TRIGGER */
 }
 
@@ -2499,8 +2498,7 @@ void pd_set_dual_role(int port, enum pd_dual_role_states state)
 	pd_set_dual_role_no_wakeup(port, state);
 
 	/* Wake task up to process change */
-	task_set_event(PD_PORT_TO_TASK_ID(port),
-		       PD_EVENT_UPDATE_DUAL_ROLE, 0);
+	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_UPDATE_DUAL_ROLE);
 }
 
 static int pd_is_power_swapping(int port)
@@ -2982,7 +2980,7 @@ void pd_task(void *u)
 		 * can hear back from our port partner if maintaining our old
 		 * connection.
 		 */
-		task_set_event(task_get_current(), PD_EVENT_TCPC_RESET, 0);
+		task_set_event(task_get_current(), PD_EVENT_TCPC_RESET);
 	}
 #endif /* defined(CONFIG_USB_PD_DUAL_ROLE) */
 	/* Set the power role if we haven't already. */
@@ -3180,7 +3178,7 @@ void pd_task(void *u)
 			/* Check if there are any more messages */
 			if (tcpm_has_pending_message(port))
 				task_set_event(PD_PORT_TO_TASK_ID(port),
-					       TASK_EVENT_WAKE, 0);
+					       TASK_EVENT_WAKE);
 		}
 
 		if (pd[port].req_suspend_state)
@@ -4881,8 +4879,7 @@ static void pd_chipset_startup(void)
 		reset_pd_cable(i);
 		task_set_event(PD_PORT_TO_TASK_ID(i),
 			       PD_EVENT_POWER_STATE_CHANGE |
-				       PD_EVENT_UPDATE_DUAL_ROLE,
-			       0);
+				       PD_EVENT_UPDATE_DUAL_ROLE);
 	}
 	CPRINTS("PD:S5->S3");
 }
@@ -4896,8 +4893,7 @@ static void pd_chipset_shutdown(void)
 		pd_set_dual_role_no_wakeup(i, PD_DRP_FORCE_SINK);
 		task_set_event(PD_PORT_TO_TASK_ID(i),
 			       PD_EVENT_POWER_STATE_CHANGE |
-				       PD_EVENT_UPDATE_DUAL_ROLE,
-			       0);
+				       PD_EVENT_UPDATE_DUAL_ROLE);
 	}
 	CPRINTS("PD:S3->S5");
 }
diff --git a/common/usb_pd_tcpc.c b/common/usb_pd_tcpc.c
index 2878e53574..d8f1739532 100644
--- a/common/usb_pd_tcpc.c
+++ b/common/usb_pd_tcpc.c
@@ -962,7 +962,7 @@ void pd_task(void *u)
 
 void pd_rx_event(int port)
 {
-	task_set_event(PD_PORT_TO_TASK_ID(port), TASK_EVENT_WAKE, 0);
+	task_set_event(PD_PORT_TO_TASK_ID(port), TASK_EVENT_WAKE);
 }
 
 int tcpc_alert_status(int port, int *alert)
@@ -1041,7 +1041,7 @@ int tcpc_set_cc(int port, int pull)
 #ifdef CONFIG_USB_POWER_DELIVERY
 	tcpc_run(port, PD_EVENT_CC);
 #else
-	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_CC, 0);
+	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_CC);
 #endif
 	return EC_SUCCESS;
 }
@@ -1139,7 +1139,7 @@ int tcpc_transmit(int port, enum tcpm_transmit_type type, uint16_t header,
 #ifdef CONFIG_USB_POWER_DELIVERY
 	tcpc_run(port, PD_EVENT_TX);
 #else
-	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_TX, 0);
+	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_TX);
 #endif
 	return EC_SUCCESS;
 }
diff --git a/common/usbc/usb_prl_sm.c b/common/usbc/usb_prl_sm.c
index 1f6dd28560..577901a173 100644
--- a/common/usbc/usb_prl_sm.c
+++ b/common/usbc/usb_prl_sm.c
@@ -1485,7 +1485,7 @@ static void rch_requesting_chunk_entry(const int port)
 	pdmsg[port].data_objs = 1;
 	pdmsg[port].ext = 1;
 	PRL_TX_SET_FLAG(port, PRL_FLAGS_MSG_XMIT);
-	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_TX, 0);
+	task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_TX);
 }
 
 static void rch_requesting_chunk_run(const int port)
diff --git a/common/usbc/usb_tc_drp_acc_trysrc_sm.c b/common/usbc/usb_tc_drp_acc_trysrc_sm.c
index c663f1ec77..fa146b3bfa 100644
--- a/common/usbc/usb_tc_drp_acc_trysrc_sm.c
+++ b/common/usbc/usb_tc_drp_acc_trysrc_sm.c
@@ -685,7 +685,7 @@ static inline void pd_set_dual_role_and_event(int port,
 		pd_update_try_source();
 
 	if (event != 0)
-		task_set_event(PD_PORT_TO_TASK_ID(port), event, 0);
+		task_set_event(PD_PORT_TO_TASK_ID(port), event);
 }
 
 void pd_set_dual_role(int port, enum pd_dual_role_states state)
@@ -1160,7 +1160,7 @@ static void bc12_role_change_handler(int port, enum pd_data_role prev_data_role,
 	}
 
 	if (event)
-		task_set_event(task_id, event, 0);
+		task_set_event(task_id, event);
 }
 
 /*
@@ -1818,7 +1818,7 @@ static __maybe_unused int reset_device_and_notify(int port)
 	while (waiting_tasks) {
 		task = __fls(waiting_tasks);
 		waiting_tasks &= ~BIT(task);
-		task_set_event(task, TASK_EVENT_PD_AWAKE, 0);
+		task_set_event(task, TASK_EVENT_PD_AWAKE);
 	}
 
 	return rv;
@@ -1845,8 +1845,7 @@ void pd_wait_exit_low_power(int port)
 		 * happen much, but it if starts occurring, we can add a guard
 		 * to prevent/reduce it.
 		 */
-		task_set_event(PD_PORT_TO_TASK_ID(port),
-			       PD_EVENT_TCPC_RESET, 0);
+		task_set_event(PD_PORT_TO_TASK_ID(port), PD_EVENT_TCPC_RESET);
 		task_wait_event_mask(TASK_EVENT_PD_AWAKE, -1);
 	}
 }
@@ -1861,7 +1860,7 @@ void pd_device_accessed(int port)
 		handle_device_access(port);
 	else
 		task_set_event(PD_PORT_TO_TASK_ID(port),
-			PD_EVENT_DEVICE_ACCESSED, 0);
+			       PD_EVENT_DEVICE_ACCESSED);
 }
 
 /*
diff --git a/common/usbc/usbc_task.c b/common/usbc/usbc_task.c
index 624c55a651..af9e7986bd 100644
--- a/common/usbc/usbc_task.c
+++ b/common/usbc/usbc_task.c
@@ -52,7 +52,7 @@ void tc_start_event_loop(int port)
 	 */
 	if (paused[port]) {
 		paused[port] = 0;
-		task_set_event(PD_PORT_TO_TASK_ID(port), TASK_EVENT_WAKE, 0);
+		task_set_event(PD_PORT_TO_TASK_ID(port), TASK_EVENT_WAKE);
 	}
 }
 
diff --git a/common/usbc_intr_task.c b/common/usbc_intr_task.c
index ae9bc1233e..cb59882d7a 100644
--- a/common/usbc_intr_task.c
+++ b/common/usbc_intr_task.c
@@ -35,7 +35,7 @@ void schedule_deferred_pd_interrupt(const int port)
 	 * that doesn't have pd int task is 0.
 	 */
 	if (pd_int_task_id[port] != 0)
-		task_set_event(pd_int_task_id[port], PD_PROCESS_INTERRUPT, 0);
+		task_set_event(pd_int_task_id[port], PD_PROCESS_INTERRUPT);
 }
 
 /*