From c7ccb4f5323b577d080021f364fef66e9514b6be Mon Sep 17 00:00:00 2001 From: EvalZero Date: Sun, 17 Mar 2019 16:01:12 +0800 Subject: [components][drivers][workqueue] add system default workqueue and delayed work. --- components/drivers/src/workqueue.c | 258 ++++++++++++++++++++++++++++++------- 1 file changed, 213 insertions(+), 45 deletions(-) (limited to 'components/drivers/src/workqueue.c') diff --git a/components/drivers/src/workqueue.c b/components/drivers/src/workqueue.c index 158ea8b69b..f2b1ae81e4 100644 --- a/components/drivers/src/workqueue.c +++ b/components/drivers/src/workqueue.c @@ -13,11 +13,12 @@ #include #ifdef RT_USING_HEAP + rt_inline rt_err_t _workqueue_work_completion(struct rt_workqueue *queue) { rt_err_t result; - - rt_enter_critical(); + + rt_enter_critical(); while (1) { /* try to take condition semaphore */ @@ -40,17 +41,17 @@ rt_inline rt_err_t _workqueue_work_completion(struct rt_workqueue *queue) } } rt_exit_critical(); - + return result; } -static void _workqueue_thread_entry(void* parameter) +static void _workqueue_thread_entry(void *parameter) { rt_base_t level; - struct rt_work* work; - struct rt_workqueue* queue; + struct rt_work *work; + struct rt_workqueue *queue; - queue = (struct rt_workqueue*) parameter; + queue = (struct rt_workqueue *) parameter; RT_ASSERT(queue != RT_NULL); while (1) @@ -67,6 +68,7 @@ static void _workqueue_thread_entry(void* parameter) work = rt_list_entry(queue->work_list.next, struct rt_work, list); rt_list_remove(&(work->list)); queue->work_current = work; + work->flags &= ~RT_WORK_STATE_PENDING; rt_hw_interrupt_enable(level); /* do work */ @@ -81,11 +83,156 @@ static void _workqueue_thread_entry(void* parameter) } } -struct rt_workqueue *rt_workqueue_create(const char* name, rt_uint16_t stack_size, rt_uint8_t priority) +static rt_err_t _workqueue_submit_work(struct rt_workqueue *queue, struct rt_work *work) +{ + rt_base_t level; + + level = rt_hw_interrupt_disable(); + if (work->flags & RT_WORK_STATE_PENDING) + { + rt_hw_interrupt_enable(level); + return -RT_EBUSY; + } + + if (queue->work_current == work) + { + rt_hw_interrupt_enable(level); + return -RT_EBUSY; + } + + /* NOTE: the work MUST be initialized firstly */ + rt_list_remove(&(work->list)); + + rt_list_insert_after(queue->work_list.prev, &(work->list)); + work->flags |= RT_WORK_STATE_PENDING; + + /* whether the workqueue is doing work */ + if (queue->work_current == RT_NULL) + { + rt_hw_interrupt_enable(level); + /* resume work thread */ + rt_thread_resume(queue->work_thread); + rt_schedule(); + } + else + { + rt_hw_interrupt_enable(level); + } + + return RT_EOK; +} + +static rt_err_t _workqueue_cancel_work(struct rt_workqueue *queue, struct rt_work *work) +{ + rt_base_t level; + + level = rt_hw_interrupt_disable(); + if (queue->work_current == work) + { + rt_hw_interrupt_enable(level); + return -RT_EBUSY; + } + rt_list_remove(&(work->list)); + work->flags &= ~RT_WORK_STATE_PENDING; + rt_hw_interrupt_enable(level); + + return RT_EOK; +} + +static rt_err_t _workqueue_cancel_delayed_work(struct rt_delayed_work *work) +{ + rt_base_t level; + int ret = RT_EOK; + + if (!work->workqueue) + { + ret = -EINVAL; + goto __exit; + } + + if (work->work.flags & RT_WORK_STATE_PENDING) + { + /* Remove from the queue if already submitted */ + ret = rt_workqueue_cancel_work(work->workqueue, &(work->work)); + if (ret) + { + goto __exit; + } + } + else + { + rt_timer_stop(&(work->timer)); + } + + level = rt_hw_interrupt_disable(); + /* Detach from workqueue */ + work->workqueue = RT_NULL; + work->work.flags &= ~(RT_WORK_STATE_PENDING); + rt_hw_interrupt_enable(level); + +__exit: + return ret; +} + +static rt_err_t _workqueue_submit_delayed_work(struct rt_workqueue *queue, + struct rt_delayed_work *work, rt_tick_t ticks) +{ + rt_base_t level; + int ret = RT_EOK; + + + /* Work cannot be active in multiple queues */ + if (work->workqueue && work->workqueue != queue) + { + ret = -RT_EINVAL; + goto __exit; + } + + /* Cancel if work has been submitted */ + if (work->workqueue == queue) + { + ret = _workqueue_cancel_delayed_work(work); + if (ret < 0) + { + goto __exit; + } + } + + level = rt_hw_interrupt_disable(); + /* Attach workqueue so the timeout callback can submit it */ + work->workqueue = queue; + rt_hw_interrupt_enable(level); + + if (!ticks) + { + /* Submit work if no ticks is 0 */ + _workqueue_submit_work(work->workqueue, &(work->work)); + } + else + { + /* Add timeout */ + rt_timer_control(&(work->timer), RT_TIMER_CTRL_SET_TIME, &ticks); + rt_timer_start(&(work->timer)); + } + +__exit: + return ret; +} + +static void _delayed_work_timeout_handler(void *parameter) +{ + struct rt_delayed_work *delayed_work; + + delayed_work = (struct rt_delayed_work *)parameter; + rt_timer_stop(&(delayed_work->timer)); + _workqueue_submit_work(delayed_work->workqueue, &(delayed_work->work)); +} + +struct rt_workqueue *rt_workqueue_create(const char *name, rt_uint16_t stack_size, rt_uint8_t priority) { struct rt_workqueue *queue = RT_NULL; - queue = (struct rt_workqueue*)RT_KERNEL_MALLOC(sizeof(struct rt_workqueue)); + queue = (struct rt_workqueue *)RT_KERNEL_MALLOC(sizeof(struct rt_workqueue)); if (queue != RT_NULL) { /* initialize work list */ @@ -107,7 +254,7 @@ struct rt_workqueue *rt_workqueue_create(const char* name, rt_uint16_t stack_siz return queue; } -rt_err_t rt_workqueue_destroy(struct rt_workqueue* queue) +rt_err_t rt_workqueue_destroy(struct rt_workqueue *queue) { RT_ASSERT(queue != RT_NULL); @@ -117,37 +264,30 @@ rt_err_t rt_workqueue_destroy(struct rt_workqueue* queue) return RT_EOK; } -rt_err_t rt_workqueue_dowork(struct rt_workqueue* queue, struct rt_work* work) +rt_err_t rt_workqueue_dowork(struct rt_workqueue *queue, struct rt_work *work) { - rt_base_t level; RT_ASSERT(queue != RT_NULL); RT_ASSERT(work != RT_NULL); - level = rt_hw_interrupt_disable(); - if (queue->work_current == work) - { - rt_hw_interrupt_enable(level); - return -RT_EBUSY; - } + return _workqueue_submit_work(queue, work); +} - /* NOTE: the work MUST be initialized firstly */ - rt_list_remove(&(work->list)); +rt_err_t rt_workqueue_submit_work(struct rt_workqueue *queue, struct rt_work *work, rt_tick_t time) +{ + RT_ASSERT(queue != RT_NULL); + RT_ASSERT(work != RT_NULL); - rt_list_insert_after(queue->work_list.prev, &(work->list)); - /* whether the workqueue is doing work */ - if (queue->work_current == RT_NULL) + if (work->type & RT_WORK_TYPE_DELAYED) { - rt_hw_interrupt_enable(level); - /* resume work thread */ - rt_thread_resume(queue->work_thread); - rt_schedule(); + return _workqueue_submit_delayed_work(queue, (struct rt_delayed_work *)work, time); + } + else + { + return _workqueue_submit_work(queue, work); } - else rt_hw_interrupt_enable(level); - - return RT_EOK; } -rt_err_t rt_workqueue_critical_work(struct rt_workqueue* queue, struct rt_work* work) +rt_err_t rt_workqueue_critical_work(struct rt_workqueue *queue, struct rt_work *work) { rt_base_t level; RT_ASSERT(queue != RT_NULL); @@ -176,26 +316,22 @@ rt_err_t rt_workqueue_critical_work(struct rt_workqueue* queue, struct rt_work* return RT_EOK; } -rt_err_t rt_workqueue_cancel_work(struct rt_workqueue* queue, struct rt_work* work) +rt_err_t rt_workqueue_cancel_work(struct rt_workqueue *queue, struct rt_work *work) { - rt_base_t level; - RT_ASSERT(queue != RT_NULL); RT_ASSERT(work != RT_NULL); - level = rt_hw_interrupt_disable(); - if (queue->work_current == work) + if (work->type & RT_WORK_TYPE_DELAYED) { - rt_hw_interrupt_enable(level); - return -RT_EBUSY; + return _workqueue_cancel_delayed_work((struct rt_delayed_work *)work); + } + else + { + return _workqueue_cancel_work(queue, work); } - rt_list_remove(&(work->list)); - rt_hw_interrupt_enable(level); - - return RT_EOK; } -rt_err_t rt_workqueue_cancel_work_sync(struct rt_workqueue* queue, struct rt_work* work) +rt_err_t rt_workqueue_cancel_work_sync(struct rt_workqueue *queue, struct rt_work *work) { rt_base_t level; @@ -212,12 +348,13 @@ rt_err_t rt_workqueue_cancel_work_sync(struct rt_workqueue* queue, struct rt_wor { rt_list_remove(&(work->list)); } + work->flags &= ~RT_WORK_STATE_PENDING; rt_hw_interrupt_enable(level); return RT_EOK; } -rt_err_t rt_workqueue_cancel_all_work(struct rt_workqueue* queue) +rt_err_t rt_workqueue_cancel_all_work(struct rt_workqueue *queue) { struct rt_list_node *node, *next; RT_ASSERT(queue != RT_NULL); @@ -233,5 +370,36 @@ rt_err_t rt_workqueue_cancel_all_work(struct rt_workqueue* queue) return RT_EOK; } -#endif +void rt_delayed_work_init(struct rt_delayed_work *work, void (*work_func)(struct rt_work *work, + void *work_data), void *work_data) +{ + rt_work_init(&(work->work), work_func, work_data); + work->work.type = RT_WORK_TYPE_DELAYED; + rt_timer_init(&(work->timer), "work", _delayed_work_timeout_handler, work, 0, + RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER); +} +#ifdef RT_USING_SYSTEM_WORKQUEUE +static struct rt_workqueue *sys_workq; + +rt_err_t rt_work_submit(struct rt_work *work, rt_tick_t time) +{ + return rt_workqueue_submit_work(sys_workq, work, time); +} + +rt_err_t rt_work_cancel(struct rt_work *work) +{ + return rt_workqueue_cancel_work(sys_workq, work); +} + +static int rt_work_sys_workqueue_init(void) +{ + sys_workq = rt_workqueue_create("sys_work", RT_SYSTEM_WORKQUEUE_STACKSIZE * 4, + RT_SYSTEM_WORKQUEUE_PRIORITY); + + return RT_EOK; +} + +INIT_DEVICE_EXPORT(rt_work_sys_workqueue_init); +#endif +#endif -- cgit v1.3.1 From c3ee1be7eee84fb0387d9b2eb2354349a22654e5 Mon Sep 17 00:00:00 2001 From: EvalZero Date: Wed, 3 Apr 2019 17:50:16 +0800 Subject: [components][drivers][workqueue] increase the default stack size of the workqueue thread. --- components/drivers/Kconfig | 16 ++++++++-------- components/drivers/src/workqueue.c | 2 +- 2 files changed, 9 insertions(+), 9 deletions(-) (limited to 'components/drivers/src/workqueue.c') diff --git a/components/drivers/Kconfig b/components/drivers/Kconfig index c883e6458b..792dc1b028 100755 --- a/components/drivers/Kconfig +++ b/components/drivers/Kconfig @@ -10,17 +10,17 @@ if RT_USING_DEVICE_IPC default 512 config RT_USING_SYSTEM_WORKQUEUE - bool "Using system default workqueue - default n + bool "Using system default workqueue" + default n if RT_USING_SYSTEM_WORKQUEUE - config RT_SYSTEM_WORKQUEUE_STACKSIZE - int "The stack size for system workqueue thread" - default 512 + config RT_SYSTEM_WORKQUEUE_STACKSIZE + int "The stack size for system workqueue thread" + default 2048 - config RT_SYSTEM_WORKQUEUE_PRIORITY - int "The priority level of system workqueue thread" - default "23 + config RT_SYSTEM_WORKQUEUE_PRIORITY + int "The priority level of system workqueue thread" + default 23 endif endif diff --git a/components/drivers/src/workqueue.c b/components/drivers/src/workqueue.c index f2b1ae81e4..d2e7dce329 100644 --- a/components/drivers/src/workqueue.c +++ b/components/drivers/src/workqueue.c @@ -394,7 +394,7 @@ rt_err_t rt_work_cancel(struct rt_work *work) static int rt_work_sys_workqueue_init(void) { - sys_workq = rt_workqueue_create("sys_work", RT_SYSTEM_WORKQUEUE_STACKSIZE * 4, + sys_workq = rt_workqueue_create("sys_work", RT_SYSTEM_WORKQUEUE_STACKSIZE, RT_SYSTEM_WORKQUEUE_PRIORITY); return RT_EOK; -- cgit v1.3.1 From 83b6260b3f05efafa8936c6c185480afc874d6cc Mon Sep 17 00:00:00 2001 From: EvalZero Date: Mon, 22 Apr 2019 11:41:17 +0800 Subject: [components][workqueue]improve delayed work for reinit. --- components/drivers/include/ipc/workqueue.h | 6 +++--- components/drivers/src/workqueue.c | 24 ++++++++++++++++++++---- 2 files changed, 23 insertions(+), 7 deletions(-) (limited to 'components/drivers/src/workqueue.c') diff --git a/components/drivers/include/ipc/workqueue.h b/components/drivers/include/ipc/workqueue.h index 09dc4354a8..31dbb53ee3 100644 --- a/components/drivers/include/ipc/workqueue.h +++ b/components/drivers/include/ipc/workqueue.h @@ -13,7 +13,8 @@ enum { - RT_WORK_STATE_PENDING, /* Work item pending state */ + RT_WORK_STATE_PENDING = 0x0001, /* Work item pending state */ + RT_WORK_STATE_SUBMITTING = 0x0002, /* Work item submitting state */ }; /** @@ -21,7 +22,7 @@ enum */ enum { - RT_WORK_TYPE_DELAYED, + RT_WORK_TYPE_DELAYED = 0x0001, }; /* workqueue implementation */ @@ -81,4 +82,3 @@ void rt_delayed_work_init(struct rt_delayed_work *work, void (*work_func)(struct #endif #endif - diff --git a/components/drivers/src/workqueue.c b/components/drivers/src/workqueue.c index d2e7dce329..7bf4bd81a7 100644 --- a/components/drivers/src/workqueue.c +++ b/components/drivers/src/workqueue.c @@ -14,6 +14,8 @@ #ifdef RT_USING_HEAP +static void _delayed_work_timeout_handler(void *parameter); + rt_inline rt_err_t _workqueue_work_completion(struct rt_workqueue *queue) { rt_err_t result; @@ -161,7 +163,14 @@ static rt_err_t _workqueue_cancel_delayed_work(struct rt_delayed_work *work) } else { - rt_timer_stop(&(work->timer)); + if (work->work.flags & RT_WORK_STATE_SUBMITTING) + { + level = rt_hw_interrupt_disable(); + rt_timer_stop(&(work->timer)); + rt_timer_detach(&(work->timer)); + work->work.flags &= ~RT_WORK_STATE_SUBMITTING; + rt_hw_interrupt_enable(level); + } } level = rt_hw_interrupt_disable(); @@ -210,8 +219,12 @@ static rt_err_t _workqueue_submit_delayed_work(struct rt_workqueue *queue, } else { + level = rt_hw_interrupt_disable(); /* Add timeout */ - rt_timer_control(&(work->timer), RT_TIMER_CTRL_SET_TIME, &ticks); + work->work.flags |= RT_WORK_STATE_SUBMITTING; + rt_timer_init(&(work->timer), "work", _delayed_work_timeout_handler, work, ticks, + RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER); + rt_hw_interrupt_enable(level); rt_timer_start(&(work->timer)); } @@ -222,9 +235,14 @@ __exit: static void _delayed_work_timeout_handler(void *parameter) { struct rt_delayed_work *delayed_work; + rt_base_t level; delayed_work = (struct rt_delayed_work *)parameter; + level = rt_hw_interrupt_disable(); rt_timer_stop(&(delayed_work->timer)); + rt_timer_detach(&(delayed_work->timer)); + delayed_work->work.flags &= ~RT_WORK_STATE_SUBMITTING; + rt_hw_interrupt_enable(level); _workqueue_submit_work(delayed_work->workqueue, &(delayed_work->work)); } @@ -375,8 +393,6 @@ void rt_delayed_work_init(struct rt_delayed_work *work, void (*work_func)(struct { rt_work_init(&(work->work), work_func, work_data); work->work.type = RT_WORK_TYPE_DELAYED; - rt_timer_init(&(work->timer), "work", _delayed_work_timeout_handler, work, 0, - RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER); } #ifdef RT_USING_SYSTEM_WORKQUEUE -- cgit v1.3.1 From badd2114575190d8ec4ab9ee0e71f6452d2bf666 Mon Sep 17 00:00:00 2001 From: tangyuxin <462747508@qq.com> Date: Mon, 5 Aug 2019 14:18:15 +0800 Subject: [components][drivers][ipc] 完善工作队列，增强稳定性 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 1. 可直接提交延时任务, 无需额外调用延时初始化 2. 修复延时任务 PENDING 时，取消任务会递归调用的问题 --- components/drivers/include/ipc/workqueue.h | 6 ++-- components/drivers/src/workqueue.c | 48 +++++++++++++++++------------- 2 files changed, 32 insertions(+), 22 deletions(-) (limited to 'components/drivers/src/workqueue.c') diff --git a/components/drivers/include/ipc/workqueue.h b/components/drivers/include/ipc/workqueue.h index 354a30c04e..23e256c420 100644 --- a/components/drivers/include/ipc/workqueue.h +++ b/components/drivers/include/ipc/workqueue.h @@ -43,13 +43,13 @@ struct rt_work void *work_data; rt_uint16_t flags; rt_uint16_t type; + struct rt_timer timer; + struct rt_workqueue *workqueue; }; struct rt_delayed_work { struct rt_work work; - struct rt_timer timer; - struct rt_workqueue *workqueue; }; #ifdef RT_USING_HEAP @@ -74,6 +74,7 @@ rt_inline void rt_work_init(struct rt_work *work, void (*work_func)(struct rt_wo rt_list_init(&(work->list)); work->work_func = work_func; work->work_data = work_data; + work->workqueue = RT_NULL; work->flags = 0; work->type = 0; } @@ -81,6 +82,7 @@ rt_inline void rt_work_init(struct rt_work *work, void (*work_func)(struct rt_wo void rt_delayed_work_init(struct rt_delayed_work *work, void (*work_func)(struct rt_work *work, void *work_data), void *work_data); +int rt_work_sys_workqueue_init(void); #endif #endif diff --git a/components/drivers/src/workqueue.c b/components/drivers/src/workqueue.c index 7bf4bd81a7..2e0280df3a 100644 --- a/components/drivers/src/workqueue.c +++ b/components/drivers/src/workqueue.c @@ -71,6 +71,7 @@ static void _workqueue_thread_entry(void *parameter) rt_list_remove(&(work->list)); queue->work_current = work; work->flags &= ~RT_WORK_STATE_PENDING; + work->workqueue = RT_NULL; rt_hw_interrupt_enable(level); /* do work */ @@ -141,7 +142,7 @@ static rt_err_t _workqueue_cancel_work(struct rt_workqueue *queue, struct rt_wor return RT_EOK; } -static rt_err_t _workqueue_cancel_delayed_work(struct rt_delayed_work *work) +static rt_err_t _workqueue_cancel_delayed_work(struct rt_work *work) { rt_base_t level; int ret = RT_EOK; @@ -152,10 +153,10 @@ static rt_err_t _workqueue_cancel_delayed_work(struct rt_delayed_work *work) goto __exit; } - if (work->work.flags & RT_WORK_STATE_PENDING) + if (work->flags & RT_WORK_STATE_PENDING) { /* Remove from the queue if already submitted */ - ret = rt_workqueue_cancel_work(work->workqueue, &(work->work)); + ret = _workqueue_cancel_work(work->workqueue, work); if (ret) { goto __exit; @@ -163,12 +164,12 @@ static rt_err_t _workqueue_cancel_delayed_work(struct rt_delayed_work *work) } else { - if (work->work.flags & RT_WORK_STATE_SUBMITTING) + if (work->flags & RT_WORK_STATE_SUBMITTING) { level = rt_hw_interrupt_disable(); rt_timer_stop(&(work->timer)); rt_timer_detach(&(work->timer)); - work->work.flags &= ~RT_WORK_STATE_SUBMITTING; + work->flags &= ~RT_WORK_STATE_SUBMITTING; rt_hw_interrupt_enable(level); } } @@ -176,7 +177,7 @@ static rt_err_t _workqueue_cancel_delayed_work(struct rt_delayed_work *work) level = rt_hw_interrupt_disable(); /* Detach from workqueue */ work->workqueue = RT_NULL; - work->work.flags &= ~(RT_WORK_STATE_PENDING); + work->flags &= ~(RT_WORK_STATE_PENDING); rt_hw_interrupt_enable(level); __exit: @@ -184,11 +185,10 @@ __exit: } static rt_err_t _workqueue_submit_delayed_work(struct rt_workqueue *queue, - struct rt_delayed_work *work, rt_tick_t ticks) + struct rt_work *work, rt_tick_t ticks) { rt_base_t level; - int ret = RT_EOK; - + rt_err_t ret = RT_EOK; /* Work cannot be active in multiple queues */ if (work->workqueue && work->workqueue != queue) @@ -215,13 +215,13 @@ static rt_err_t _workqueue_submit_delayed_work(struct rt_workqueue *queue, if (!ticks) { /* Submit work if no ticks is 0 */ - _workqueue_submit_work(work->workqueue, &(work->work)); + ret = _workqueue_submit_work(work->workqueue, work); } else { level = rt_hw_interrupt_disable(); /* Add timeout */ - work->work.flags |= RT_WORK_STATE_SUBMITTING; + work->flags |= RT_WORK_STATE_SUBMITTING; rt_timer_init(&(work->timer), "work", _delayed_work_timeout_handler, work, ticks, RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_SOFT_TIMER); rt_hw_interrupt_enable(level); @@ -234,16 +234,17 @@ __exit: static void _delayed_work_timeout_handler(void *parameter) { - struct rt_delayed_work *delayed_work; + struct rt_work *delayed_work; rt_base_t level; - delayed_work = (struct rt_delayed_work *)parameter; + delayed_work = (struct rt_work *)parameter; level = rt_hw_interrupt_disable(); rt_timer_stop(&(delayed_work->timer)); rt_timer_detach(&(delayed_work->timer)); - delayed_work->work.flags &= ~RT_WORK_STATE_SUBMITTING; + delayed_work->flags &= ~RT_WORK_STATE_SUBMITTING; + delayed_work->type &= ~RT_WORK_TYPE_DELAYED; rt_hw_interrupt_enable(level); - _workqueue_submit_work(delayed_work->workqueue, &(delayed_work->work)); + _workqueue_submit_work(delayed_work->workqueue, delayed_work); } struct rt_workqueue *rt_workqueue_create(const char *name, rt_uint16_t stack_size, rt_uint8_t priority) @@ -295,9 +296,14 @@ rt_err_t rt_workqueue_submit_work(struct rt_workqueue *queue, struct rt_work *wo RT_ASSERT(queue != RT_NULL); RT_ASSERT(work != RT_NULL); + if (time > 0) + { + work->type |= RT_WORK_TYPE_DELAYED; + } + if (work->type & RT_WORK_TYPE_DELAYED) { - return _workqueue_submit_delayed_work(queue, (struct rt_delayed_work *)work, time); + return _workqueue_submit_delayed_work(queue, work, time); } else { @@ -341,7 +347,7 @@ rt_err_t rt_workqueue_cancel_work(struct rt_workqueue *queue, struct rt_work *wo if (work->type & RT_WORK_TYPE_DELAYED) { - return _workqueue_cancel_delayed_work((struct rt_delayed_work *)work); + return _workqueue_cancel_delayed_work(work); } else { @@ -391,8 +397,7 @@ rt_err_t rt_workqueue_cancel_all_work(struct rt_workqueue *queue) void rt_delayed_work_init(struct rt_delayed_work *work, void (*work_func)(struct rt_work *work, void *work_data), void *work_data) { - rt_work_init(&(work->work), work_func, work_data); - work->work.type = RT_WORK_TYPE_DELAYED; + rt_work_init(&work->work, work_func, work_data); } #ifdef RT_USING_SYSTEM_WORKQUEUE @@ -408,8 +413,11 @@ rt_err_t rt_work_cancel(struct rt_work *work) return rt_workqueue_cancel_work(sys_workq, work); } -static int rt_work_sys_workqueue_init(void) +int rt_work_sys_workqueue_init(void) { + if (sys_workq != RT_NULL) + return 0; + sys_workq = rt_workqueue_create("sys_work", RT_SYSTEM_WORKQUEUE_STACKSIZE, RT_SYSTEM_WORKQUEUE_PRIORITY); -- cgit v1.3.1