coreboot-mirror
/
chrome-ec
mirror of https://review.coreboot.org/chrome-ec.git
1
0
Fork 0
Code Issues Releases Wiki Activity

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>
This commit is contained in:
Dawid Niedzwiecki 2020-11-06 09:20:56 +01:00 committed by Commit Bot
parent a23ef3d074
commit f96f176c30
139 changed files with 317 additions and 341 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
baseboard/grunt/baseboard.c
View File

@ -197,7 +197,7 @@ static void anx74xx_cable_det_handler(void)
* and if in normal mode, then there is no need to trigger a tcpc reset.
*/
if (cable_det && !reset_n)
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET, 0);
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET);
}
DECLARE_DEFERRED(anx74xx_cable_det_handler);

4
baseboard/volteer/baseboard.c
View File

@ -174,11 +174,11 @@ void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

4
baseboard/zork/variant_trembyle.c
View File

@ -347,11 +347,11 @@ void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

4
board/akemi/board.c
View File

@ -90,11 +90,11 @@ static void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

4
board/asurada/board.c
View File

@ -200,9 +200,9 @@ struct bc12_config bc12_ports[CONFIG_USB_PD_PORT_MAX_COUNT] = {
static void bc12_interrupt(enum gpio_signal signal)
{
if (signal == GPIO_USB_C0_BC12_INT_ODL)
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
else
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
static void board_sub_bc12_init(void)

2
board/boten/board.c
View File

@ -53,7 +53,7 @@ static void usb_c0_interrupt(enum gpio_signal s)
* chip.
*/
schedule_deferred_pd_interrupt(0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void c0_ccsbu_ovp_interrupt(enum gpio_signal s)

2
board/burnet/board.c
View File

@ -237,7 +237,7 @@ int pd_snk_is_vbus_provided(int port)
void bc12_interrupt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
/*

2
board/cerise/board.c
View File

@ -254,7 +254,7 @@ int pd_snk_is_vbus_provided(int port)
void bc12_interrupt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
#ifndef VARIANT_KUKUI_NO_SENSORS

6
board/cheza/board.c
View File

@ -91,12 +91,12 @@ static void vbus1_evt(enum gpio_signal signal)
static void usb0_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void usb1_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
static void anx74xx_cable_det_handler(void)
@ -114,7 +114,7 @@ static void anx74xx_cable_det_handler(void)
* and if in normal mode, then there is no need to trigger a tcpc reset.
*/
if (cable_det && !reset_n)
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET, 0);
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET);
}
DECLARE_DEFERRED(anx74xx_cable_det_handler);

4
board/coachz/board.c
View File

@ -85,12 +85,12 @@ static void tcpc_alert_event(enum gpio_signal signal)
static void usb0_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void usb1_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
static void ppc_interrupt(enum gpio_signal signal)

2
board/coral/board.c
View File

@ -100,7 +100,7 @@ static void anx74xx_cable_det_handler(void)
* and if in normal mode, then there is no need to trigger a tcpc reset.
*/
if (cable_det && !reset_n)
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET, 0);
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET);
}
DECLARE_DEFERRED(anx74xx_cable_det_handler);

4
board/dalboz/board.c
View File

@ -517,11 +517,11 @@ void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

2
board/damu/board.c
View File

@ -254,7 +254,7 @@ int pd_snk_is_vbus_provided(int port)
void bc12_interrupt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
#ifndef VARIANT_KUKUI_NO_SENSORS

4
board/dirinboz/board.c
View File

@ -434,11 +434,11 @@ void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

4
board/dratini/board.c
View File

@ -113,11 +113,11 @@ static void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

4
board/drawcia/board.c
View File

@ -58,7 +58,7 @@ DECLARE_DEFERRED(check_c0_line);
static void notify_c0_chips(void)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
sm5803_interrupt(0);
}
@ -93,7 +93,7 @@ DECLARE_DEFERRED(check_c1_line);
static void notify_c1_chips(void)
{
schedule_deferred_pd_interrupt(1);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
sm5803_interrupt(1);
}

4
board/elm/board.c
View File

@ -67,7 +67,7 @@ DECLARE_DEFERRED(deferred_reset_pd_mcu);
void usb_evt(enum gpio_signal signal)
{
if (!gpio_get_level(GPIO_BC12_WAKE_L))
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
#include "gpio_list.h"
@ -206,7 +206,7 @@ void deferred_reset_pd_mcu(void)
gpio_set_level(GPIO_USB_C0_RST, 1);
hook_call_deferred(&deferred_reset_pd_mcu_data, 1*MSEC);
/* on PD reset, trigger PD task to reset state */
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET, 0);
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET);
break;
case 3:
/*

4
board/eve/board.c
View File

@ -120,7 +120,7 @@ static void anx74xx_c0_cable_det_handler(void)
* and if in normal mode, then there is no need to trigger a tcpc reset.
*/
if (cable_det && !reset_n)
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET, 0);
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET);
}
DECLARE_DEFERRED(anx74xx_c0_cable_det_handler);
@ -139,7 +139,7 @@ static void anx74xx_c1_cable_det_handler(void)
* and if in normal mode, then there is no need to trigger a tcpc reset.
*/
if (cable_det && !reset_n)
task_set_event(TASK_ID_PD_C1, PD_EVENT_TCPC_RESET, 0);
task_set_event(TASK_ID_PD_C1, PD_EVENT_TCPC_RESET);
}
DECLARE_DEFERRED(anx74xx_c1_cable_det_handler);

2
board/fennel/board.c
View File

@ -253,7 +253,7 @@ int pd_snk_is_vbus_provided(int port)
void bc12_interrupt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
#ifndef VARIANT_KUKUI_NO_SENSORS

4
board/galtic/board.c
View File

@ -51,7 +51,7 @@ DECLARE_DEFERRED(check_c0_line);
static void notify_c0_chips(void)
{
schedule_deferred_pd_interrupt(0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void check_c0_line(void)
@ -85,7 +85,7 @@ DECLARE_DEFERRED(check_c1_line);
static void notify_c1_chips(void)
{
schedule_deferred_pd_interrupt(1);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
static void check_c1_line(void)

4
board/gumboz/board.c
View File

@ -434,11 +434,11 @@ void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

6
board/halvor/board.c
View File

@ -318,13 +318,13 @@ void halvor_bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C2_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P2, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P2, USB_CHG_EVENT_BC12);
break;
default:

4
board/hatch/board.c
View File

@ -94,11 +94,11 @@ static void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

4
board/helios/board.c
View File

@ -84,11 +84,11 @@ static void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

2
board/jacuzzi/board.c
View File

@ -256,7 +256,7 @@ int pd_snk_is_vbus_provided(int port)
void bc12_interrupt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
#ifndef VARIANT_KUKUI_NO_SENSORS

4
board/jinlon/board.c
View File

@ -99,11 +99,11 @@ static void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

2
board/kappa/board.c
View File

@ -236,7 +236,7 @@ int pd_snk_is_vbus_provided(int port)
void bc12_interrupt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void board_init(void)

4
board/kindred/board.c
View File

@ -116,11 +116,11 @@ static void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

4
board/kohaku/board.c
View File

@ -83,11 +83,11 @@ static void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

4
board/lantis/board.c
View File

@ -58,7 +58,7 @@ DECLARE_DEFERRED(check_c0_line);
static void notify_c0_chips(void)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
sm5803_interrupt(0);
}
@ -93,7 +93,7 @@ DECLARE_DEFERRED(check_c1_line);
static void notify_c1_chips(void)
{
schedule_deferred_pd_interrupt(1);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
sm5803_interrupt(1);
}

4
board/lazor/board.c
View File

@ -70,12 +70,12 @@ static void tcpc_alert_event(enum gpio_signal signal)
static void usb0_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void usb1_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
static void usba_oc_deferred(void)

4
board/madoo/board.c
View File

@ -62,7 +62,7 @@ static void notify_c0_chips(void)
* chip. Therefore we'll need to check both ICs.
*/
schedule_deferred_pd_interrupt(0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void check_c0_line(void)
@ -97,7 +97,7 @@ DECLARE_DEFERRED(check_c1_line);
static void notify_c1_chips(void)
{
schedule_deferred_pd_interrupt(1);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
static void check_c1_line(void)

4
board/magolor/board.c
View File

@ -75,7 +75,7 @@ static void usb_c0_interrupt(enum gpio_signal s)
* chip. Therefore we'll need to check both ICs.
*/
tcpc_alert_event(s);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void sub_usb_c1_interrupt(enum gpio_signal s)
@ -85,7 +85,7 @@ static void sub_usb_c1_interrupt(enum gpio_signal s)
* chip. Therefore we'll need to check both ICs.
*/
tcpc_alert_event(s);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
#include "gpio_list.h"

4
board/mchpevb1/board.c
View File

@ -192,12 +192,12 @@ void vbus1_evt(enum gpio_signal signal)
void usb0_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
void usb1_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
#endif

4
board/metaknight/board.c
View File

@ -70,7 +70,7 @@ static void usb_c0_interrupt(enum gpio_signal s)
* chip. Therefore we'll need to check both ICs.
*/
tcpc_alert_event(s);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void sub_usb_c1_interrupt(enum gpio_signal s)
@ -80,7 +80,7 @@ static void sub_usb_c1_interrupt(enum gpio_signal s)
* chip. Therefore we'll need to check both ICs.
*/
tcpc_alert_event(s);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
static void sub_hdmi_hpd_interrupt(enum gpio_signal s)

4
board/mushu/board.c
View File

@ -96,11 +96,11 @@ static void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

4
board/nami/board.c
View File

@ -139,12 +139,12 @@ void vbus1_evt(enum gpio_signal signal)
void usb0_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
void usb1_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
#include "gpio_list.h"

4
board/nautilus/board.c
View File

@ -103,12 +103,12 @@ void vbus1_evt(enum gpio_signal signal)
void usb0_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
void usb1_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
#include "gpio_list.h"

4
board/nightfury/board.c
View File

@ -85,11 +85,11 @@ static void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

6
board/oak/board.c
View File

@ -70,8 +70,8 @@ void pd_mcu_interrupt(enum gpio_signal signal)
#if BOARD_REV >= OAK_REV4
void usb_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_INTR, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_INTR, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_INTR);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_INTR);
}
#endif /* BOARD_REV >= OAK_REV4 */
@ -545,7 +545,7 @@ void vbus_task(void *u)
if (wake)
task_set_event(port ? TASK_ID_USB_CHG_P1 :
TASK_ID_USB_CHG_P0,
USB_CHG_EVENT_BC12, 0);
USB_CHG_EVENT_BC12);
}
task_wait_event(-1);
}

2
board/palkia/board.c
View File

@ -94,7 +94,7 @@ static void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
default:

2
board/pompom/board.c
View File

@ -62,7 +62,7 @@ static void tcpc_alert_event(enum gpio_signal signal)
static void usb0_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void usba_oc_deferred(void)

6
board/poppy/board.c
View File

@ -108,12 +108,12 @@ void vbus1_evt(enum gpio_signal signal)
void usb0_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
void usb1_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
#ifdef CONFIG_USB_PD_TCPC_LOW_POWER
@ -132,7 +132,7 @@ static void anx74xx_cable_det_handler(void)
* and if in normal mode, then there is no need to trigger a tcpc reset.
*/
if (cable_det && !reset_n)
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET, 0);
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET);
}
DECLARE_DEFERRED(anx74xx_cable_det_handler);

4
board/rammus/board.c
View File

@ -105,12 +105,12 @@ void vbus1_evt(enum gpio_signal signal)
void usb0_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
void usb1_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
#include "gpio_list.h"

2
board/reef/board.c
View File

@ -98,7 +98,7 @@ static void anx74xx_cable_det_handler(void)
* and if in normal mode, then there is no need to trigger a tcpc reset.
*/
if (cable_det && !reset_n)
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET, 0);
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET);
}
DECLARE_DEFERRED(anx74xx_cable_det_handler);

2
board/reef_mchp/board.c
View File

@ -132,7 +132,7 @@ static void anx74xx_cable_det_handler(void)
* and if in normal mode, then there is no need to trigger a tcpc reset.
*/
if (cable_det && !reset_n)
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET, 0);
task_set_event(TASK_ID_PD_C0, PD_EVENT_TCPC_RESET);
}
DECLARE_DEFERRED(anx74xx_cable_det_handler);
/* from firmware-reef-9042.B */

4
board/samus_pd/board.c
View File

@ -109,12 +109,12 @@ void vbus1_evt(enum gpio_signal signal)
void usb0_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
void usb1_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
static void chipset_s5_to_s3(void)

4
board/sasuke/board.c
View File

@ -53,7 +53,7 @@ static void usb_c0_interrupt(enum gpio_signal s)
* chip. Therefore we'll need to check both ICs.
*/
tcpc_alert_event(s);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void sub_usb_c1_interrupt(enum gpio_signal s)
@ -63,7 +63,7 @@ static void sub_usb_c1_interrupt(enum gpio_signal s)
* chip. Therefore we'll need to check both ICs.
*/
tcpc_alert_event(s);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
static void sub_hdmi_hpd_interrupt(enum gpio_signal s)

4
board/shuboz/board.c
View File

@ -448,11 +448,11 @@ void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

2
board/stern/board.c
View File

@ -254,7 +254,7 @@ int pd_snk_is_vbus_provided(int port)
void bc12_interrupt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
#ifndef VARIANT_KUKUI_NO_SENSORS

4
board/storo/board.c
View File

@ -53,7 +53,7 @@ DECLARE_DEFERRED(check_c0_line);
static void notify_c0_chips(void)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
sm5803_interrupt(0);
}
@ -88,7 +88,7 @@ DECLARE_DEFERRED(check_c1_line);
static void notify_c1_chips(void)
{
schedule_deferred_pd_interrupt(1);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
sm5803_interrupt(1);
}

4
board/stryke/board.c
View File

@ -93,11 +93,11 @@ static void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
case GPIO_USB_C1_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
break;
default:

4
board/trogdor/board.c
View File

@ -68,12 +68,12 @@ static void tcpc_alert_event(enum gpio_signal signal)
static void usb0_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void usb1_evt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
static void usba_oc_deferred(void)

2
board/twinkie/simpletrace.c
View File

@ -197,7 +197,7 @@ void rx_event(void)
pd_rx_disable_monitoring(0);
/* trigger the analysis in the task */
#ifdef HAS_TASK_SNIFFER
task_set_event(TASK_ID_SNIFFER, 1 << i, 0);
task_set_event(TASK_ID_SNIFFER, 1 << i);
#endif
/* start reception only one CC line */
break;

4
board/twinkie/sniffer.c
View File

@ -109,7 +109,7 @@ static void ep_tx(void)
: EP_BUF_SIZE;
STM32_TOGGLE_EP(USB_EP_SNIFFER, EP_TX_MASK, EP_TX_VALID, 0);
/* wake up the processing */
task_set_event(TASK_ID_SNIFFER, USB_EVENT, 0);
task_set_event(TASK_ID_SNIFFER, USB_EVENT);
}
static void ep_event(enum usb_ep_event evt)
@ -218,7 +218,7 @@ void tim_dma_handler(void)
else
tim_rx1_handler(stat);
/* time to process the samples */
task_set_event(TASK_ID_SNIFFER, USB_EVENT, 0);
task_set_event(TASK_ID_SNIFFER, USB_EVENT);
}
DECLARE_IRQ(STM32_IRQ_DMA_CHANNEL_4_7, tim_dma_handler, 1);

2
board/vilboz/board.c
View File

@ -375,7 +375,7 @@ void bc12_interrupt(enum gpio_signal signal)
{
switch (signal) {
case GPIO_USB_C0_BC12_INT_ODL:
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
break;
default:

4
board/waddledee/board.c
View File

@ -53,7 +53,7 @@ DECLARE_DEFERRED(check_c0_line);
static void notify_c0_chips(void)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
sm5803_interrupt(0);
}
@ -88,7 +88,7 @@ DECLARE_DEFERRED(check_c1_line);
static void notify_c1_chips(void)
{
schedule_deferred_pd_interrupt(1);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
sm5803_interrupt(1);
}

4
board/waddledoo/board.c
View File

@ -58,7 +58,7 @@ static void notify_c0_chips(void)
* chip. Therefore we'll need to check both ICs.
*/
schedule_deferred_pd_interrupt(0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
static void check_c0_line(void)
@ -93,7 +93,7 @@ DECLARE_DEFERRED(check_c1_line);
static void notify_c1_chips(void)
{
schedule_deferred_pd_interrupt(1);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
}
static void check_c1_line(void)

4
board/wheelie/board.c
View File

@ -45,7 +45,7 @@
/* C0 interrupt line shared by BC 1.2 and charger */
static void usb_c0_interrupt(enum gpio_signal s)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
sm5803_interrupt(0);
}
@ -53,7 +53,7 @@ static void usb_c0_interrupt(enum gpio_signal s)
static void usb_c1_interrupt(enum gpio_signal s)
{
schedule_deferred_pd_interrupt(1);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P1, USB_CHG_EVENT_BC12);
sm5803_interrupt(1);
}

2
board/willow/board.c
View File

@ -253,7 +253,7 @@ int pd_snk_is_vbus_provided(int port)
void bc12_interrupt(enum gpio_signal signal)
{
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12, 0);
task_set_event(TASK_ID_USB_CHG_P0, USB_CHG_EVENT_BC12);
}
#ifndef VARIANT_KUKUI_NO_SENSORS

4
board/zinger/runtime.c
View File

@ -67,7 +67,7 @@ void interrupt_enable(void)
asm("cpsie i");
}
uint32_t task_set_event(task_id_t tskid, uint32_t event, int wait)
uint32_t task_set_event(task_id_t tskid, uint32_t event)
{
last_event = event;
@ -229,7 +229,7 @@ uint32_t task_wait_event_mask(uint32_t event_mask, int timeout_us)
/* Restore any pending events not in the event_mask */
if (evt & ~event_mask)
task_set_event(0, evt & ~event_mask, 0);
task_set_event(0, evt & ~event_mask);
return evt & event_mask;
}

2
chip/ish/heci.c
View File

@ -706,7 +706,7 @@ static int handle_flow_control_cmd(struct hbm_flow_control *flow_ctrl)
mutex_unlock(&connect->cred_lock);
if (waiting_task)
task_set_event(waiting_task, TASK_EVENT_IPC_READY, 0);
task_set_event(waiting_task, TASK_EVENT_IPC_READY);
return EC_SUCCESS;
}

2
chip/ish/i2c.c
View File

@ -446,7 +446,7 @@ static void i2c_interrupt_handler(struct i2c_context *ctx)
/* disable interrupts */
i2c_intr_switch(ctx->base, DISABLE_INT);
task_set_event(ctx->wait_task_id, TASK_EVENT_I2C_IDLE, 0);
task_set_event(ctx->wait_task_id, TASK_EVENT_I2C_IDLE);
}
static void i2c_isr_bus0(void)

2
chip/ish/ipc_heci.c
View File

@ -377,7 +377,7 @@ static void handle_msg_recv_interrupt(const uint32_t peer_id)
if (!invalid_msg) {
/* send event to task */
task_set_event(ctx->msg_events[protocol].task_id,
ctx->msg_events[protocol].event, 0);
ctx->msg_events[protocol].event);
} else {
CPRINTS("discard msg (%d) : %d", protocol, invalid_msg);

2
chip/it83xx/adc.c
View File

@ -208,7 +208,7 @@ void adc_interrupt(void)
task_disable_irq(IT83XX_IRQ_ADC);
/* Wake up the task which was waiting for the interrupt */
if (task_waiting != TASK_ID_INVALID)
task_set_event(task_waiting, TASK_EVENT_ADC_DONE, 0);
task_set_event(task_waiting, TASK_EVENT_ADC_DONE);
}
#ifdef CONFIG_ADC_VOLTAGE_COMPARATOR

2
chip/it83xx/i2c.c
View File

@ -769,7 +769,7 @@ void i2c_interrupt(int port)
/* If done doing work, wake up the task waiting for the transfer */
if (!i2c_transaction(port)) {
task_disable_irq(i2c_ctrl_regs[port].irq);
task_set_event(id, TASK_EVENT_I2C_IDLE, 0);
task_set_event(id, TASK_EVENT_I2C_IDLE);
}
}

7
chip/it83xx/intc.c
View File

@ -40,7 +40,7 @@ static void chip_pd_irq(enum usbpd_port port)
IT83XX_USBPD_ISR(port) = USBPD_REG_MASK_HARD_RESET_DETECT;
USBPD_SW_RESET(port);
task_set_event(PD_PORT_TO_TASK_ID(port),
PD_EVENT_RX_HARD_RESET, 0);
PD_EVENT_RX_HARD_RESET);
}
if (USBPD_IS_RX_DONE(port)) {
@ -59,7 +59,7 @@ static void chip_pd_irq(enum usbpd_port port)
/* clear TX done interrupt */
IT83XX_USBPD_ISR(port) = USBPD_REG_MASK_MSG_TX_DONE;
task_set_event(PD_PORT_TO_TASK_ID(port),
TASK_EVENT_PHY_TX_DONE, 0);
TASK_EVENT_PHY_TX_DONE);
}
if (IS_ENABLED(IT83XX_INTC_PLUG_IN_OUT_SUPPORT)) {
@ -84,8 +84,7 @@ static void chip_pd_irq(enum usbpd_port port)
/* clear type-c device plug in/out detect interrupt */
IT83XX_USBPD_TCDCR(port) |=
USBPD_REG_PLUG_IN_OUT_DETECT_STAT;
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);
}
}
}

2
chip/lm4/adc.c
View File

@ -189,7 +189,7 @@ static void handle_interrupt(int ss)
/* Wake up the task which was waiting on the interrupt, if any */
if (id != TASK_ID_INVALID)
task_set_event(id, TASK_EVENT_ADC_DONE, 0);
task_set_event(id, TASK_EVENT_ADC_DONE);
}
void ss0_interrupt(void) { handle_interrupt(0); }

2
chip/lm4/i2c.c
View File

@ -393,7 +393,7 @@ static void handle_interrupt(int port)
/* If done doing work, wake up the task waiting for the transfer */
if (!i2c_do_work(port))
task_set_event(id, TASK_EVENT_I2C_IDLE, 0);
task_set_event(id, TASK_EVENT_I2C_IDLE);
}
void i2c0_interrupt(void) { handle_interrupt(0); }

2
chip/mchp/i2c.c
View File

@ -950,7 +950,7 @@ static void handle_interrupt(int controller)
/* Wake up the task which was waiting on the I2C interrupt, if any. */
if (id != TASK_ID_INVALID)
task_set_event(id, TASK_EVENT_I2C_IDLE, 0);
task_set_event(id, TASK_EVENT_I2C_IDLE);
}
void i2c0_interrupt(void) { handle_interrupt(0); }

2
chip/mec1322/i2c.c
View File

@ -517,7 +517,7 @@ static void handle_interrupt(int controller)
/* Wake up the task which was waiting on the I2C interrupt, if any. */
if (id != TASK_ID_INVALID)
task_set_event(id, TASK_EVENT_I2C_IDLE, 0);
task_set_event(id, TASK_EVENT_I2C_IDLE);
}
void i2c0_interrupt(void) { handle_interrupt(0); }

2
chip/npcx/adc.c
View File

@ -338,7 +338,7 @@ void adc_interrupt(void)
/* Wake up the task which was waiting for the interrupt */
if (task_waiting != TASK_ID_INVALID)
task_set_event(task_waiting, TASK_EVENT_ADC_DONE, 0);
task_set_event(task_waiting, TASK_EVENT_ADC_DONE);
}
for (i = NPCX_THRCTS_THR1_STS; i < NPCX_ADC_THRESH_CNT; i++) {

2
chip/npcx/cec.c
View File

@ -505,7 +505,7 @@ void enter_state(enum cec_state new_state)
addr = cec_rx.transfer.buf[0] & 0x0f;
if (addr == cec_addr || addr == CEC_BROADCAST_ADDR) {
task_set_event(TASK_ID_CEC,
TASK_EVENT_RECEIVED_DATA, 0);
TASK_EVENT_RECEIVED_DATA);
}
timeout = DATA_ZERO_HIGH_TICKS;
} else {

13
chip/npcx/i2c.c
View File

@ -493,8 +493,7 @@ void i2c_done(int controller)
task_disable_irq(i2c_irqs[controller]);
/* Notify upper layer */
task_set_event(p_status->task_waiting,
TASK_EVENT_I2C_IDLE, 0);
task_set_event(p_status->task_waiting, TASK_EVENT_I2C_IDLE);
CPUTS("-END");
}
@ -551,8 +550,7 @@ static void i2c_handle_receive(int controller)
/* Set error code */
p_status->err_code = SMB_OK;
/* Notify upper layer of missing data */
task_set_event(p_status->task_waiting,
TASK_EVENT_I2C_IDLE, 0);
task_set_event(p_status->task_waiting, TASK_EVENT_I2C_IDLE);
CPUTS("-END");
}
}
@ -647,8 +645,7 @@ static void i2c_fifo_handle_receive(int controller)
/* Set error code */
p_status->err_code = SMB_OK;
/* Notify upper layer of missing data */
task_set_event(p_status->task_waiting,
TASK_EVENT_I2C_IDLE, 0);
task_set_event(p_status->task_waiting, TASK_EVENT_I2C_IDLE);
CPUTS("-END");
}
@ -767,7 +764,7 @@ void i2c_master_int_handler (int controller)
p_status->err_code = SMB_BUS_ERROR;
/* Notify upper layer */
p_status->oper_state = SMB_IDLE;
task_set_event(p_status->task_waiting, TASK_EVENT_I2C_IDLE, 0);
task_set_event(p_status->task_waiting, TASK_EVENT_I2C_IDLE);
CPUTS("-BER");
/*
@ -791,7 +788,7 @@ void i2c_master_int_handler (int controller)
p_status->err_code = SMB_MASTER_NO_ADDRESS_MATCH;
/* Notify upper layer */
p_status->oper_state = SMB_IDLE;
task_set_event(p_status->task_waiting, TASK_EVENT_I2C_IDLE, 0);
task_set_event(p_status->task_waiting, TASK_EVENT_I2C_IDLE);
CPUTS("-NA");
}

2
chip/npcx/peci.c
View File

@ -271,7 +271,7 @@ DECLARE_HOOK(HOOK_INIT, peci_init, HOOK_PRIO_DEFAULT);
/* If received a PECI DONE interrupt, post the event to PECI task */
void peci_done_interrupt(void){
if (peci_pending_task_id != NULL_PENDING_TASK_ID)
task_set_event(peci_pending_task_id, TASK_EVENT_PECI_DONE, 0);
task_set_event(peci_pending_task_id, TASK_EVENT_PECI_DONE);
peci_sts = NPCX_PECI_CTL_STS & 0x18;
/* no matter what, clear status bit again */
SET_BIT(NPCX_PECI_CTL_STS, NPCX_PECI_CTL_STS_DONE);

2
chip/npcx/ps2.c
View File

@ -293,7 +293,7 @@ void ps2_int_handler(void)
/* Change the PS/2 module to receive mode */
CLEAR_BIT(NPCX_PS2_PSCON, NPCX_PS2_PSCON_XMT);
ps2_ch_data[active_ch].opr_mode = PS2_RX_MODE;
task_set_event(task_waiting, TASK_EVENT_PS2_DONE, 0);
task_set_event(task_waiting, TASK_EVENT_PS2_DONE);
} else {
if (!ps2_is_rx_error(active_ch)) {
uint8_t data_read = NPCX_PS2_PSDAT;

2
chip/stm32/dma-stm32f4.c
View File

@ -261,7 +261,7 @@ static inline void _dma_wake_callback(void *cb_data)
task_id_t id = (task_id_t)(int)cb_data;
if (id != TASK_ID_INVALID)
task_set_event(id, TASK_EVENT_DMA_TC, 0);
task_set_event(id, TASK_EVENT_DMA_TC);
}
void dma_enable_tc_interrupt(enum dma_channel stream)

2
chip/stm32/dma.c
View File

@ -276,7 +276,7 @@ static inline void _dma_wake_callback(void *cb_data)
{
task_id_t id = (task_id_t)(int)cb_data;
if (id != TASK_ID_INVALID)
task_set_event(id, TASK_EVENT_DMA_TC, 0);
task_set_event(id, TASK_EVENT_DMA_TC);
}
void dma_enable_tc_interrupt(enum dma_channel channel)

2
chip/stm32/i2c-stm32f4.c
View File

@ -79,7 +79,7 @@ static inline void _i2c_dma_wake_callback(void *cb_data, int port)
task_id_t id = (task_id_t)(int)cb_data;
if (id != TASK_ID_INVALID)
task_set_event(id, TASK_EVENT_I2C_COMPLETION(port), 0);
task_set_event(id, TASK_EVENT_I2C_COMPLETION(port));
}
/* Each callback is hardcoded to an I2C channel. */

19
chip/stm32/ucpd-stm32gx.c
View File

@ -777,7 +777,7 @@ static void ucpd_send_good_crc(int port, uint16_t rx_header)
ucpd_tx_buffers[TX_MSG_GOOD_CRC].type = tx_type;
/* Notify ucpd task that a GoodCRC message tx request is pending */
task_set_event(TASK_ID_UCPD, UCPD_EVT_GOOD_CRC_REQ, 0);
task_set_event(TASK_ID_UCPD, UCPD_EVT_GOOD_CRC_REQ);
}
int stm32gx_ucpd_transmit(int port,
@ -800,7 +800,7 @@ int stm32gx_ucpd_transmit(int port,
len - 2);
/* Notify ucpd task that a TCPM message tx request is pending */
task_set_event(TASK_ID_UCPD, UCPD_EVT_TCPM_MSG_REQ, 0);
task_set_event(TASK_ID_UCPD, UCPD_EVT_TCPM_MSG_REQ);
return EC_SUCCESS;
}
@ -847,7 +847,7 @@ void stm32gx_ucpd1_irq(void)
/* Check for CC events, set event to wake PD task */
if (sr & (STM32_UCPD_SR_TYPECEVT1 | STM32_UCPD_SR_TYPECEVT2))
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);
/*
* Check for Tx events. tx_mask includes all status bits related to the
@ -858,18 +858,17 @@ void stm32gx_ucpd1_irq(void)
if (sr & tx_done_mask) {
/* Check for tx message complete */
if (sr & STM32_UCPD_SR_TXMSGSENT) {
task_set_event(TASK_ID_UCPD, UCPD_EVT_TX_MSG_SUCCESS,
0);
task_set_event(TASK_ID_UCPD, UCPD_EVT_TX_MSG_SUCCESS);
#ifdef CONFIG_STM32G4_UCPD_DEBUG
ucpd_log_mark_tx_comp();
#endif
} else if (sr & (STM32_UCPD_SR_TXMSGABT |
STM32_UCPD_SR_TXMSGDISC |STM32_UCPD_SR_TXUND)) {
task_set_event(TASK_ID_UCPD, UCPD_EVT_TX_MSG_FAIL, 0);
task_set_event(TASK_ID_UCPD, UCPD_EVT_TX_MSG_FAIL);
} else if (sr & STM32_UCPD_SR_HRSTSENT) {
task_set_event(TASK_ID_UCPD, UCPD_EVT_HR_DONE, 0);
task_set_event(TASK_ID_UCPD, UCPD_EVT_HR_DONE);
} else if (sr & STM32_UCPD_SR_HRSTDISC) {
task_set_event(TASK_ID_UCPD, UCPD_EVT_HR_FAIL, 0);
task_set_event(TASK_ID_UCPD, UCPD_EVT_HR_FAIL);
}
/* Disable Tx interrupts */
ucpd_tx_interrupts_enable(port, 0);
@ -906,7 +905,7 @@ void stm32gx_ucpd1_irq(void)
ucpd_send_good_crc(port, *rx_header);
} else {
task_set_event(TASK_ID_UCPD,
UCPD_EVT_RX_GOOD_CRC, 0);
UCPD_EVT_RX_GOOD_CRC);
ucpd_crc_id = PD_HEADER_ID(*rx_header);
}
}
@ -915,7 +914,7 @@ void stm32gx_ucpd1_irq(void)
if (sr & STM32_UCPD_SR_RXHRSTDET) {
/* hard reset received */
pd_execute_hard_reset(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);
hook_call_deferred(&ucpd_hard_reset_rx_log_data, 0);
}

2
chip/stm32/usb_pd_phy.c
View File

@ -303,7 +303,7 @@ static void tx_dma_done(void *data)
pd_tx_disable(port, polarity);
#if defined(CONFIG_COMMON_RUNTIME) && defined(CONFIG_DMA_DEFAULT_HANDLERS)
task_set_event(PD_PORT_TO_TASK_ID(port), TASK_EVENT_DMA_TC, 0);
task_set_event(PD_PORT_TO_TASK_ID(port), TASK_EVENT_DMA_TC);
#endif
}

6
common/fpsensor/fpsensor.c
View File

@ -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;
}

2
common/fpsensor/fpsensor_state.c
View File

@ -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;

2
common/host_command.c
View File

@ -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;
}

4
common/host_command_pd.c
View File

@ -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

2
common/lightbar.c
View File

@ -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);
}

10
common/motion_sense.c
View File

@ -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));

4
common/rwsig.c
View File

@ -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)

2
common/timer.c
View File

@ -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)

2
common/usb_charger.c
View File

@ -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) \

2
common/usb_common.c
View File

@ -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

5
common/usb_pd_alt_mode_dfp.c
View File

@ -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)

28
common/usb_pd_protocol.c
View File

@ -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");
}

6
common/usb_pd_tcpc.c
View File

@ -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;
}

2
common/usbc/usb_prl_sm.c
View File

@ -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)

11
common/usbc/usb_tc_drp_acc_trysrc_sm.c
View File

@ -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);
}
/*

2
common/usbc/usbc_task.c
View File

@ -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);
}
}

2
common/usbc_intr_task.c
View File

@ -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);
}
/*

12
core/cortex-m/task.c
View File

@ -426,7 +426,7 @@ static uint32_t __wait_evt(int timeout_us, task_id_t resched)
return evt;
}
uint32_t task_set_event(task_id_t tskid, uint32_t event, int wait)
uint32_t task_set_event(task_id_t tskid, uint32_t event)
{
task_ *receiver = __task_id_to_ptr(tskid);
ASSERT(receiver);
@ -443,10 +443,7 @@ uint32_t task_set_event(task_id_t tskid, uint32_t event, int wait)
need_resched_or_profiling = 1;
#endif
} else {
if (wait)
return __wait_evt(-1, tskid);
else
__schedule(0, tskid);
__schedule(0, tskid);
}
return 0;
@ -765,8 +762,7 @@ int task_reset_cleanup(void)
*/
if (notify_id < TASK_ID_COUNT)
task_set_event(notify_id,
TASK_EVENT_RESET_DONE,
0);
TASK_EVENT_RESET_DONE);
}
}
@ -917,7 +913,7 @@ void mutex_unlock(struct mutex *mtx)
waiters &= ~BIT(id);
/* Somebody is waiting on the mutex */
task_set_event(id, TASK_EVENT_MUTEX, 0);
task_set_event(id, TASK_EVENT_MUTEX);
}
/* Ensure no event is remaining from mutex wake-up */

26
core/cortex-m0/task.c
View File

@ -354,7 +354,7 @@ static uint32_t __wait_evt(int timeout_us, task_id_t resched)
return evt;
}
uint32_t task_set_event(task_id_t tskid, uint32_t event, int wait)
uint32_t task_set_event(task_id_t tskid, uint32_t event)
{
task_ *receiver = __task_id_to_ptr(tskid);
ASSERT(receiver);
@ -374,19 +374,15 @@ uint32_t task_set_event(task_id_t tskid, uint32_t event, int wait)
CPU_SCB_ICSR = BIT(28);
}
} else {
if (wait) {
return __wait_evt(-1, tskid);
} else {
/*
* We need to ensure that the execution priority is
* actually decreased after the "cpsie i" in the atomic
* operation above else the "svc" in the __schedule
* call below will trigger a HardFault.
* Use a barrier to force it at that point.
*/
asm volatile("isb");
__schedule(0, tskid);
}
/*
* We need to ensure that the execution priority is
* actually decreased after the "cpsie i" in the atomic
* operation above else the "svc" in the __schedule
* call below will trigger a HardFault.
* Use a barrier to force it at that point.
*/
asm volatile("isb");
__schedule(0, tskid);
}
return 0;
@ -535,7 +531,7 @@ void mutex_unlock(struct mutex *mtx)
waiters &= ~BIT(id);
/* Somebody is waiting on the mutex */
task_set_event(id, TASK_EVENT_MUTEX, 0);
task_set_event(id, TASK_EVENT_MUTEX);
}
/* Ensure no event is remaining from mutex wake-up */

Some files were not shown because too many files have changed in this diff Show More