1 /*
2 // Copyright (C) 2022 Beken Corporation
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <common/bk_include.h>
16 #include <components/event.h>
17 #include "event.h"
18 #include <components/log.h>
19 #include "bk_list.h"
20 #include <os/mem.h>
21 #include <modules/wifi_types.h>
22
23 static beken_queue_t s_event_queue = NULL;
24 static beken_thread_t s_event_task = NULL;
25 static struct list_head s_event_module_list;
26 static bool s_event_inited = false;
27
event_is_inited(void)28 static bool event_is_inited(void)
29 {
30 return s_event_inited;
31 }
32
event_is_invalid(event_module_t event_module,int event_id)33 static bool event_is_invalid(event_module_t event_module, int event_id)
34 {
35 if ((event_module >= EVENT_MOD_COUNT) || (event_module < 0))
36 return true;
37
38 if ((event_id != EVENT_ID_ALL) && (event_id < 0))
39 return true;
40
41 return false;
42 }
43
register_cb_to_cb_list(struct list_head * cb_list,event_register_info_t * reg_info)44 static int register_cb_to_cb_list(struct list_head *cb_list, event_register_info_t *reg_info)
45 {
46 struct list_head *pos, *next;
47 event_cb_node_t *cb_node;
48 event_cb_node_t *new_cb_node = NULL;
49
50 EVENT_LOGD("register cb to cb list(%p)\n", cb_list);
51
52 list_for_each_safe(pos, next, cb_list) {
53 cb_node = list_entry(pos, event_cb_node_t, next);
54 if (cb_node->event_cb == reg_info->event_cb) {
55 EVENT_LOGD("event <%d %d> cb exist\n", reg_info->event_module_id,
56 reg_info->event_id);
57 return BK_ERR_EVENT_CB_EXIST;
58 }
59 }
60
61 new_cb_node = (event_cb_node_t *) os_zalloc(sizeof(event_cb_node_t));
62 if (!new_cb_node) {
63 EVENT_LOGE("failed to alloc new cb node\n");
64 return BK_ERR_NO_MEM;
65 }
66
67 EVENT_LOGD("new cb node(%p)\n", new_cb_node);
68 new_cb_node->event_cb = reg_info->event_cb;
69 new_cb_node->event_cb_arg = reg_info->event_cb_arg;
70 list_add_tail(&new_cb_node->next, cb_list);
71
72 return BK_OK;
73 }
74
register_cb_to_event_node_list(struct list_head * event_node_list,event_register_info_t * reg_info)75 static int register_cb_to_event_node_list(struct list_head *event_node_list,
76 event_register_info_t *reg_info)
77 {
78 struct list_head *pos, *next;
79 event_node_t *event_node = NULL;
80 event_node_t *new_event_node = NULL;
81 int ret;
82
83 EVENT_LOGD("register cb to event node(%p)\n", event_node_list);
84 list_for_each_safe(pos, next, event_node_list) {
85 event_node = list_entry(pos, event_node_t, next);
86 if (event_node->event_id == reg_info->event_id) {
87 return register_cb_to_cb_list(&event_node->cb_list,
88 reg_info);
89 }
90 }
91
92 new_event_node = (event_node_t *)os_zalloc(sizeof(event_node_t));
93 if (!new_event_node) {
94 EVENT_LOGE("failed to alloc event node\n");
95 return BK_ERR_NO_MEM;
96 }
97
98 EVENT_LOGD("new event node(%p)\n", new_event_node);
99 INIT_LIST_HEAD(&new_event_node->next);
100 INIT_LIST_HEAD(&new_event_node->cb_list);
101 new_event_node->event_id = reg_info->event_id;
102
103 ret = register_cb_to_cb_list(&new_event_node->cb_list, reg_info);
104 if (ret != BK_OK) {
105 os_free(new_event_node);
106 return ret;
107 }
108
109 list_add_tail(&new_event_node->next, event_node_list);
110 return BK_OK;
111 }
112
register_cb_to_module_node(event_module_node_t * module_node,event_register_info_t * reg_info)113 static int register_cb_to_module_node(event_module_node_t *module_node,
114 event_register_info_t *reg_info)
115 {
116 EVENT_LOGD("register cb to module node(%p)\n", module_node);
117 if (reg_info->event_id == EVENT_ID_ALL)
118 return register_cb_to_cb_list(&module_node->cb_list, reg_info);
119 else
120 return register_cb_to_event_node_list(&module_node->event_node_list, reg_info);
121 }
122
register_cb(event_register_info_t * reg_info)123 static int register_cb(event_register_info_t *reg_info)
124 {
125 event_module_node_t *new_module_node = NULL;
126 event_module_node_t *module_node = NULL;
127 struct list_head *pos, *next;
128 int ret = 0;
129
130 EVENT_LOGD("handle event register, event<%d %d %p %p>\n",
131 reg_info->event_module_id, reg_info->event_id, reg_info->event_cb,
132 reg_info->event_cb_arg);
133
134 list_for_each_safe(pos, next, &s_event_module_list) {
135 module_node = list_entry(pos, event_module_node_t, next);
136 if (reg_info->event_module_id == module_node->event_module_id)
137 return register_cb_to_module_node(module_node, reg_info);
138 }
139
140 new_module_node = (event_module_node_t *)os_zalloc(sizeof(event_module_node_t));
141 if (!new_module_node)
142 return BK_ERR_NO_MEM;
143
144 EVENT_LOGD("new event module=%p\n", new_module_node);
145 new_module_node->event_module_id = reg_info->event_module_id;
146 INIT_LIST_HEAD(&new_module_node->next);
147 INIT_LIST_HEAD(&new_module_node->event_node_list);
148 INIT_LIST_HEAD(&new_module_node->cb_list);
149 ret = register_cb_to_module_node(new_module_node, reg_info);
150 if (ret != BK_OK) {
151 os_free(new_module_node);
152 return ret;
153 }
154
155 list_add_tail(&new_module_node->next, &s_event_module_list);
156 return BK_OK;
157 }
158
unregister_cb_from_cb_list(struct list_head * cb_list,event_register_info_t * unreg_info)159 static int unregister_cb_from_cb_list(struct list_head *cb_list,
160 event_register_info_t *unreg_info)
161 {
162 struct list_head *pos, *next;
163 event_cb_node_t *cb_node;
164
165 EVENT_LOGD("unregister cb from cb list(%p)\n", cb_list);
166
167 list_for_each_safe(pos, next, cb_list) {
168 cb_node = list_entry(pos, event_cb_node_t, next);
169 if (cb_node->event_cb == unreg_info->event_cb) {
170 EVENT_LOGD("free cb_node(%p)\n", cb_node);
171 list_del(pos);
172 os_free(cb_node);
173 return BK_OK;
174 }
175 }
176
177 EVENT_LOGD("event <%d %d %p> doesn't exist\n", unreg_info->event_module_id,
178 unreg_info->event_id, unreg_info->event_cb);
179 return BK_ERR_EVENT_NO_CB;
180 }
181
unregister_cb_from_event_node_list(struct list_head * event_node_list,event_register_info_t * unreg_info)182 static int unregister_cb_from_event_node_list(struct list_head *event_node_list,
183 event_register_info_t *unreg_info)
184 {
185 struct list_head *pos, *next;
186 event_node_t *event_node = NULL;
187 int ret;
188
189 EVENT_LOGD("unregister cb from event node(%p)\n", event_node_list);
190 list_for_each_safe(pos, next, event_node_list) {
191 event_node = list_entry(pos, event_node_t, next);
192 if (event_node->event_id == unreg_info->event_id) {
193 ret = unregister_cb_from_cb_list(&event_node->cb_list,
194 unreg_info);
195
196 if (list_empty(&event_node->cb_list)) {
197 EVENT_LOGD("free event node(%p)\n", event_node);
198 list_del(pos);
199 os_free(event_node);
200 }
201
202 return ret;
203 }
204 }
205
206 EVENT_LOGD("event <%d %d %p> doesn't exist\n", unreg_info->event_module_id,
207 unreg_info->event_id, unreg_info->event_cb);
208 return BK_ERR_EVENT_NO_CB;
209 }
210
unregister_cb_from_module_node(event_module_node_t * module_node,event_register_info_t * unreg_info)211 static int unregister_cb_from_module_node(event_module_node_t *module_node,
212 event_register_info_t *unreg_info)
213 {
214 EVENT_LOGD("unregister cb from module node(%p)\n", module_node);
215 if (unreg_info->event_id == EVENT_ID_ALL)
216 return unregister_cb_from_cb_list(&module_node->cb_list, unreg_info);
217 else
218 return unregister_cb_from_event_node_list(&module_node->event_node_list, unreg_info);
219
220 return BK_ERR_EVENT_NO_CB;
221 }
222
unregister_cb(event_register_info_t * unreg_info)223 static int unregister_cb(event_register_info_t *unreg_info)
224 {
225 event_module_node_t *module_node = NULL;
226 struct list_head *pos, *next;
227 int ret;
228
229 EVENT_LOGD("handle event unregister, event<%d %d %p>\n",
230 unreg_info->event_module_id, unreg_info->event_id, unreg_info->event_cb);
231
232 list_for_each_safe(pos, next, &s_event_module_list) {
233 module_node = list_entry(pos, event_module_node_t, next);
234 if (unreg_info->event_module_id == module_node->event_module_id) {
235 ret = unregister_cb_from_module_node(module_node, unreg_info);
236 if (list_empty(&module_node->cb_list) &&
237 list_empty(&module_node->event_node_list)) {
238 EVENT_LOGD("free module node(%p)\n", module_node);
239 list_del(pos);
240 os_free(module_node);
241 return ret;
242 }
243
244 return ret;
245 }
246 }
247
248 EVENT_LOGD("event <%d %d %p> doesn't exist\n", unreg_info->event_module_id,
249 unreg_info->event_id, unreg_info->event_cb);
250 return BK_ERR_EVENT_NO_CB;
251 }
252
event_task_init(void)253 static void event_task_init(void)
254 {
255 INIT_LIST_HEAD(&s_event_module_list);
256 }
257
event_deinit_cb_list(struct list_head * cb_list)258 static void event_deinit_cb_list(struct list_head *cb_list)
259 {
260 struct list_head *pos, *next;
261 event_cb_node_t *cb_node;
262
263 list_for_each_safe(pos, next, cb_list) {
264 cb_node = list_entry(pos, event_cb_node_t, next);
265 list_del(pos);
266 os_free(cb_node);
267 EVENT_LOGD("free cb(%p)\n", cb_node);
268 }
269 }
270
event_deinit_module_node(event_module_node_t * event_module)271 static void event_deinit_module_node(event_module_node_t *event_module)
272 {
273 struct list_head *pos, *next;
274 event_node_t *event_node = NULL;
275
276 event_deinit_cb_list(&event_module->cb_list);
277 list_for_each_safe(pos, next, &event_module->event_node_list) {
278 event_node = list_entry(pos, event_node_t, next);
279 list_del(pos);
280 event_deinit_cb_list(&event_node->cb_list);
281 os_free(event_node);
282 EVENT_LOGD("free event node(%p)\n", event_node);
283 }
284 os_free(event_module);
285 EVENT_LOGD("free module(%p)\n", event_module);
286 }
287
event_deinit(void)288 static void event_deinit(void)
289 {
290 event_module_node_t *module_node = NULL;
291 struct list_head *pos, *next;
292
293 EVENT_LOGD("event deinit\n");
294 list_for_each_safe(pos, next, &s_event_module_list) {
295 module_node = list_entry(pos, event_module_node_t, next);
296 list_del(pos);
297 event_deinit_module_node(module_node);
298 }
299
300 INIT_LIST_HEAD(&s_event_module_list);
301 }
302
event_task_deinit(void)303 static void event_task_deinit(void)
304 {
305 EVENT_LOGI("event task deinit\n");
306
307 event_deinit();
308 if (s_event_queue) {
309 rtos_deinit_queue(&s_event_queue);
310 s_event_queue = NULL;
311 }
312
313 if (s_event_task) {
314 rtos_delete_thread(&s_event_task);
315 s_event_task = NULL;
316 }
317 }
318
event_post_to_cb_list(struct list_head * cb_list,event_info_t * event_info)319 static int event_post_to_cb_list(struct list_head *cb_list, event_info_t *event_info)
320 {
321 struct list_head *pos, *next;
322 event_cb_node_t *cb_node;
323
324 list_for_each_safe(pos, next, cb_list) {
325 cb_node = list_entry(pos, event_cb_node_t, next);
326 cb_node->event_cb(cb_node->event_cb_arg, event_info->event_module_id,
327 event_info->event_id, event_info->event_data);
328 }
329
330 return BK_OK;
331 }
332
event_post_to_module(event_module_node_t * module_node,event_info_t * event_info)333 static int event_post_to_module(event_module_node_t *module_node,
334 event_info_t *event_info)
335 {
336 struct list_head *pos, *next;
337 event_node_t *event_node;
338
339 event_post_to_cb_list(&module_node->cb_list, event_info);
340
341 list_for_each_safe(pos, next, &module_node->event_node_list) {
342 event_node = list_entry(pos, event_node_t, next);
343 if (event_node->event_id == event_info->event_id) {
344 event_post_to_cb_list(&event_node->cb_list, event_info);
345 break;
346 }
347 }
348
349 return BK_OK;
350 }
351
event_post(event_info_t * event_info)352 static int event_post(event_info_t *event_info)
353 {
354 event_module_node_t *module_node;
355 struct list_head *pos, *next;
356 int ret;
357
358 if (event_is_invalid(event_info->event_module_id, event_info->event_id))
359 return BK_ERR_EVENT_MOD_OR_ID;
360
361 list_for_each_safe(pos, next, &s_event_module_list) {
362 module_node = list_entry(pos, event_module_node_t, next);
363 if (module_node->event_module_id == event_info->event_module_id) {
364 ret = event_post_to_module(module_node, event_info);
365 if (event_info->event_data)
366 os_free(event_info->event_data);
367 return ret;
368 }
369 }
370
371 if (event_info->event_data)
372 os_free(event_info->event_data);
373
374 EVENT_LOGW("event <%d %d> has no cb\n", event_info->event_module_id, event_info->event_id);
375 return BK_OK;
376 }
377
378 #if EVENT_DEBUG
event_dump_cb_list(event_module_t module_id,int event_id,struct list_head * cb_list)379 static void event_dump_cb_list(event_module_t module_id, int event_id, struct list_head *cb_list)
380 {
381 struct list_head *pos, *next;
382 event_cb_node_t *cb_node;
383
384 list_for_each_safe(pos, next, cb_list) {
385 cb_node = list_entry(pos, event_cb_node_t, next);
386 BK_LOG_RAW("%9x %8x %-p %-p\n", module_id, event_id,
387 cb_node->event_cb, cb_node->event_cb_arg);
388 }
389 }
390
event_dump_module_node(event_module_node_t * module_node)391 static void event_dump_module_node(event_module_node_t *module_node)
392 {
393 struct list_head *pos, *next;
394 event_node_t *event_node;
395
396 event_dump_cb_list(module_node->event_module_id, EVENT_ID_ALL, &module_node->cb_list);
397 list_for_each_safe(pos, next, &module_node->event_node_list) {
398 event_node = list_entry(pos, event_node_t, next);
399 event_dump_cb_list(module_node->event_module_id, event_node->event_id,
400 &event_node->cb_list);
401 }
402 }
403
event_dump(void)404 static int event_dump(void)
405 {
406 struct list_head *pos, *next;
407 event_module_node_t *module_node;
408
409 BK_LOG_RAW("\nevent dump result:\n");
410 BK_LOG_RAW("%9s %8s %8s %8s\n", "module_id", "event_id", "cb", "arg");
411 BK_LOG_RAW("--------- -------- -------- --------\n");
412 list_for_each_safe(pos, next, &s_event_module_list) {
413 module_node = list_entry(pos, event_module_node_t, next);
414 event_dump_module_node(module_node);
415 }
416 return BK_OK;
417 }
418 #endif
419
event_task_handle_msg(event_msg_t * msg)420 static int event_task_handle_msg(event_msg_t *msg)
421 {
422 if (!msg) {
423 EVENT_LOGE("null event msg\n");
424 return BK_ERR_EVENT_NULL_MSG;
425 }
426
427 switch (msg->msg_type) {
428 case EVENT_MSG_REGISTER:
429 return register_cb(&msg->msg.register_info);
430 break;
431 case EVENT_MSG_UNREGISTER:
432 return unregister_cb(&msg->msg.register_info);
433 case EVENT_MSG_POST:
434 return event_post(&msg->msg.event_info);
435 #if EVENT_DEBUG
436 case EVENT_MSG_DUMP:
437 return event_dump();
438 #endif
439 default:
440 EVENT_LOGE("invalid event msg\n");
441 return BK_ERR_EVENT_UNKNOWN_MSG;
442 }
443
444 return BK_OK;
445 }
446
event_task(beken_thread_arg_t arg)447 static void event_task(beken_thread_arg_t arg)
448 {
449 event_msg_t *msg = NULL;
450 int event_ret;
451
452 event_task_init();
453
454 while (1) {
455 rtos_pop_from_queue(&s_event_queue, &msg, BEKEN_WAIT_FOREVER);
456
457 if (msg && msg->msg_type == EVENT_MSG_DEINIT)
458 break;
459
460 event_ret = event_task_handle_msg(msg);
461
462 if (msg->is_sync_msg) {
463 msg->sync_msg_ret = event_ret;
464 rtos_set_semaphore(&msg->sync_msg_sem);
465 } else {
466 os_free(msg);
467 msg = NULL;
468 }
469 }
470
471 event_task_deinit();
472 }
473
event_send_msg_to_event_task(event_msg_t * pmsg,uint32_t timeout)474 static int event_send_msg_to_event_task(event_msg_t *pmsg, uint32_t timeout)
475 {
476 int rtos_ret;
477
478 if (pmsg->is_sync_msg) {
479 rtos_ret = rtos_init_semaphore(&pmsg->sync_msg_sem, 1);
480 if (rtos_ret != kNoErr)
481 return BK_ERR_EVENT_INIT_SEM;
482 }
483
484 rtos_ret = rtos_push_to_queue(&s_event_queue, &pmsg, timeout);
485 if (rtos_ret != kNoErr) {
486 if (pmsg->is_sync_msg)
487 rtos_deinit_semaphore(&pmsg->sync_msg_sem);
488
489 return BK_ERR_EVENT_POST_QUEUE;
490 }
491
492 if (pmsg->is_sync_msg) {
493 rtos_get_semaphore(&pmsg->sync_msg_sem, BEKEN_NEVER_TIMEOUT);
494 rtos_deinit_semaphore(&pmsg->sync_msg_sem);
495 return pmsg->sync_msg_ret;
496 } else
497 return BK_OK;
498 }
499
bk_event_init(void)500 bk_err_t bk_event_init(void)
501 {
502 int ret;
503
504 //Not protect. We assume caller will NOT call bk_event_init/deinit concurrently.
505 if (event_is_inited()) {
506 EVENT_LOGD("event already init, ignore request");
507 return BK_OK;
508 }
509
510 ret = rtos_init_queue(&s_event_queue, "eventq", sizeof(event_msg_t *), EVENT_QUEUE_SIZE);
511 if (kNoErr != ret) {
512 EVENT_LOGE("failed to create event queue\n");
513 return BK_ERR_EVENT_CREATE_QUEUE;
514 }
515
516 ret = rtos_create_thread(&s_event_task, EVENT_TASK_PRIORITY, "event",
517 (beken_thread_function_t)event_task, EVENT_TASK_STACK_SIZE*2, 0);
518 if (kNoErr != ret) {
519 rtos_deinit_queue(&s_event_queue);
520 s_event_queue = NULL;
521 EVENT_LOGE("failed to create event task\n");
522 return BK_ERR_EVENT_CREATE_TASK;
523 }
524
525 s_event_inited = true;
526 EVENT_LOGD("inited\n");
527 return BK_OK;
528 }
529
530 /* Currently we don't have scenario that need to deinit the event module,
531 * so we haven't make bk_event_deinit() thread-safe yet. We can make it
532 * thread-safe once we have real customer requirements about event deinit.
533 */
bk_event_deinit(void)534 bk_err_t bk_event_deinit(void)
535 {
536 event_msg_t *pmsg;
537
538 if (!event_is_inited())
539 return BK_OK;
540
541 s_event_inited = false;
542
543 pmsg = os_zalloc(sizeof(event_msg_t));
544 if (!pmsg)
545 return BK_ERR_NO_MEM;
546
547 pmsg->msg_type = EVENT_MSG_DEINIT;
548 pmsg->is_sync_msg = false;
549
550 if (BK_OK != event_send_msg_to_event_task(pmsg, BEKEN_WAIT_FOREVER)) {
551 os_free(pmsg);
552 return BK_FAIL;
553 }
554
555 return BK_OK;
556 }
557
bk_event_register_cb(event_module_t event_module_id,int event_id,event_cb_t event_cb,void * event_cb_arg)558 bk_err_t bk_event_register_cb(event_module_t event_module_id, int event_id,
559 event_cb_t event_cb, void *event_cb_arg)
560 {
561 event_msg_t msg = {0};
562 event_msg_t *pmsg = &msg;
563
564 if (!event_is_inited()) {
565 EVENT_LOGE("event not init\n");
566 return BK_ERR_EVENT_NOT_INIT;
567 }
568
569 if (event_is_invalid(event_module_id, event_id))
570 return BK_ERR_EVENT_MOD_OR_ID;
571
572 EVENT_LOGD("register event <%d %d %p %p>\n", event_module_id, event_id,
573 event_cb, event_cb_arg);
574 pmsg->msg_type = EVENT_MSG_REGISTER;
575 pmsg->is_sync_msg = true;
576 pmsg->sync_msg_ret = BK_OK;
577 pmsg->msg.register_info.event_module_id = event_module_id;
578 pmsg->msg.register_info.event_id = event_id;
579 pmsg->msg.register_info.event_cb = event_cb;
580 pmsg->msg.register_info.event_cb_arg = event_cb_arg;
581
582 return event_send_msg_to_event_task(pmsg, BEKEN_WAIT_FOREVER);
583 }
584
bk_event_unregister_cb(event_module_t event_module_id,int event_id,event_cb_t event_cb)585 bk_err_t bk_event_unregister_cb(event_module_t event_module_id, int event_id,
586 event_cb_t event_cb)
587 {
588 event_msg_t msg = {0};
589 event_msg_t *pmsg = &msg;
590
591 if (!event_is_inited()) {
592 EVENT_LOGE("unregister fail, event not init\n");
593 return BK_ERR_EVENT_NOT_INIT;
594 }
595
596 if (event_is_invalid(event_module_id, event_id))
597 return BK_ERR_EVENT_MOD_OR_ID;
598
599 pmsg->msg_type = EVENT_MSG_UNREGISTER;
600 pmsg->msg.register_info.event_module_id = event_module_id;
601 pmsg->msg.register_info.event_id = event_id;
602 pmsg->msg.register_info.event_cb = event_cb;
603 pmsg->is_sync_msg = true;
604 pmsg->sync_msg_ret = BK_OK;
605
606 EVENT_LOGD("unregister event <%d, %d, %p>\n", event_module_id, event_id, event_cb);
607 return event_send_msg_to_event_task(pmsg, BEKEN_WAIT_FOREVER);
608 }
609
bk_event_post(event_module_t event_module_id,int event_id,void * event_data,size_t event_data_size,uint32_t timeout)610 bk_err_t bk_event_post(event_module_t event_module_id, int event_id,
611 void *event_data, size_t event_data_size, uint32_t timeout)
612 {
613 void *event_data_copy = NULL;
614 event_msg_t *pmsg;
615 bk_err_t ret = BK_OK;
616
617 if (!event_is_inited())
618 return BK_ERR_EVENT_NOT_INIT;
619
620 if (event_is_invalid(event_module_id, event_id))
621 return BK_ERR_EVENT_MOD_OR_ID;
622
623 pmsg = os_zalloc(sizeof(event_msg_t));
624 if (!pmsg)
625 return BK_ERR_NO_MEM;
626
627 if (event_data_size > 0) {
628 event_data_copy = os_zalloc(event_data_size);
629 if (!event_data_copy) {
630 os_free(pmsg);
631 return BK_ERR_NO_MEM;
632 }
633
634 os_memcpy(event_data_copy, event_data, event_data_size);
635 }
636
637 pmsg->msg_type = EVENT_MSG_POST;
638 pmsg->msg.event_info.event_module_id = event_module_id;
639 pmsg->msg.event_info.event_id = event_id;
640 pmsg->msg.event_info.event_data = event_data_copy;
641 pmsg->is_sync_msg = false;
642
643 EVENT_LOGD("post event <%d %d %p %u>\n", event_module_id, event_id, event_data, timeout);
644 ret = event_send_msg_to_event_task(pmsg, timeout);
645 if (BK_OK != ret) {
646 os_free(event_data_copy);
647 os_free(pmsg);
648 }
649
650 return ret;
651 }
652
bk_event_dump(void)653 bk_err_t bk_event_dump(void)
654 {
655 #if EVENT_DEBUG
656 event_msg_t *pmsg;
657
658 if (!event_is_inited())
659 return BK_OK;
660
661 pmsg = os_zalloc(sizeof(event_msg_t));
662 if (!pmsg)
663 return BK_ERR_NO_MEM;
664
665 pmsg->msg_type = EVENT_MSG_DUMP;
666 pmsg->is_sync_msg = false;
667 EVENT_LOGD("dump event\n");
668
669 if (BK_OK != event_send_msg_to_event_task(pmsg, 0)) {
670 os_free(pmsg);
671 return BK_FAIL;
672 }
673 #endif
674 return BK_OK;
675 }
676