1 /**
2 * Copyright (c) 2020 HiSilicon (Shanghai) Technologies CO., LIMITED.
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 * Description: Application core main function for standard \n
16 *
17 * History: \n
18 * 2022-07-27, Create file. \n
19 */
20
21 #include "cmsis_os2.h"
22 #include "stdlib.h"
23 #include "uart.h"
24 #include "exception.h"
25 #include "timer.h"
26 #include "arch/cache.h"
27 #include "osal_task.h"
28 #include "systick.h"
29 #include "systick_porting.h"
30 #include "tcxo.h"
31 #include "watchdog.h"
32 #include "sfc.h"
33 #include "security_init.h"
34 #include "tsensor.h"
35 #ifdef MBEDTLS_HARDEN_OPEN
36 #include "mbedtls_harden_adapt.h"
37 #endif
38 #include "soc_osal.h"
39 #ifdef AT_COMMAND
40 #include "at_config.h"
41 #include "at_product.h"
42 #ifdef CONFIG_AT_SUPPORT_ZDIAG
43 #include "at_zdiag.h"
44 #endif
45 #ifdef CONFIG_AT_SUPPORT_PLT
46 #include "at_plt_cmd_register.h"
47 #endif
48 #endif
49 #include "chip_io.h"
50 #if defined(DEVICE_ONLY) // 这个宏指的是BGLE DEVICE ONLY
51 #include "wvt_uart.h"
52 #endif
53 #include "flash_patch.h"
54
55 #ifdef TEST_SUITE
56 #include "test_suite_uart.h"
57 #include "test_suite.h"
58 #include "test_auxiliary.h"
59 #endif
60
61 #ifdef LOG_SUPPORT
62 #include "log_memory_region.h"
63 #include "log_common.h"
64 #include "log_uart.h"
65 #include "log_oam_logger.h"
66 #include "log_oml_exception.h"
67 #endif
68
69 #include <los_memory.h>
70 #include "share_mem_config.h"
71 #include "pmp_cfg.h"
72 #include "dyn_mem.h"
73 #ifdef HSO_SUPPORT
74 #include "dfx_system_init.h"
75 #include "diag_rom_api.h"
76 #include "soc_diag_util.h"
77 #undef THIS_FILE_ID
78 #define THIS_FILE_ID _MAIN_C_
79 #endif
80 #include "arch/exception.h"
81 #include "los_task_pri.h"
82
83 #ifdef CONFIG_MIDDLEWARE_SUPPORT_NV
84 #include "nv.h"
85 #if defined(CONFIG_OTA_UPDATE_SUPPORT)
86 #include "nv_config.h"
87 #if (defined(CONFIG_NV_SUPPORT_OTA_UPDATE) && (defined(NV_YES)) && (CONFIG_NV_SUPPORT_OTA_UPDATE == NV_YES))
88 #include "upg_common_porting.h"
89 #include "cipher.h"
90 #include "nv_upg.h"
91 #endif
92 #endif
93 #endif
94 #ifdef CONFIG_MIDDLEWARE_SUPPORT_LFS
95 #include "littlefs_adapt.h"
96 #endif
97
98 #include "pinctrl.h"
99 #include "gpio.h"
100 #include "partition.h"
101 #include "main.h"
102
103 #ifdef BOARD_ASIC
104 #include "clock_init.h"
105 #endif
106 #include "efuse.h"
107 #include "efuse_porting.h"
108 #ifdef WIFI_TASK_EXIST
109 #include "mac_addr.h"
110 #endif
111
112 #include "app_init.h"
113 #include "reboot_porting.h"
114 #include "xo_trim_porting.h"
115 #if defined(CONFIG_PM_SUPPORT_POWER_EXCEPTION_DEBUG) && (CONFIG_PM_SUPPORT_POWER_EXCEPTION_DEBUG == 1)
116 #include "pm_pwr_dbg.h"
117 #endif
118 #ifdef CONFIG_PM_SUPPORT_SRV_DECOUPLING
119 #include "pm_porting.h"
120 #endif
121
122 #define WDT_TIMEOUT_S 15 /* wdg超时时间15s */
123
124 #define TASK_PRIORITY_LOG 25
125 #define TASK_PRIORITY_APP 27
126 #define TASK_PRIORITY_CMD 1
127 #define TASK_PRIORITY_BT 1
128 #define TASK_PRIORITY_SDK 12
129 #define TASK_PRIORITY_WF 25
130 #define TASK_PRIORITY_BTH_SDK 13
131 #define TASK_PRIORITY_BTH_RECV 10
132 #define TASK_PRIORITY_SRV 12
133
134 #define STACK_SIZE_BASELINE 0x200
135 #define FS_EXTEND_STACK (STACK_SIZE_BASELINE * 3)
136 #define APP_STACK_SIZE 0x800
137 #define TESTSUITE_STACK_SIZE 0x1000
138 #define HSO_STACK_SIZE 0x800
139 #define BT_STACK_SIZE (STACK_SIZE_BASELINE * 4 + FS_EXTEND_STACK)
140 #define BT_SDK_STACK_SIZE 0x800
141 #define BTH_SDK_STACK_SIZE 0x200
142 #define BTH_RECV_STACK_SIZE 0x800
143 #define BTH_SERVICE_STACK_SIZE (STACK_SIZE_BASELINE * 8)
144 #define AT_STACK_SIZE 0x2000
145 #define WIFI_STACK_SIZE 0x2000
146
147 #ifdef CONFIG_RADAR_SERVICE
148 #define TASK_PRIORITY_RD_D 23
149 #define TASK_PRIORITY_RD_F 24
150 #define RADAR_STACK_SIZE_D 0x800
151 #define RADAR_STACK_SIZE_F 0x2600
152 #define RADAR_STACK_SIZE 0x400
153 #endif
154
155 typedef struct {
156 const char *name;
157 uint32_t stack_size;
158 uint32_t priority;
159 osal_kthread_handler func;
160 } app_task_definition_t;
161
162 static osStatus_t g_kernel_state = osError;
163
164 #ifdef TEST_SUITE
165 static void cmd_processor_entry(void *args);
166 static void test_suite_main_add_functions(void);
167 static int test_fun(int argc, const char *argv[]);
168 #endif
169
170 #ifdef CONFIG_RADAR_SERVICE
171 static int radar_driver_task_weakref(void *param) __attribute__ ((weakref("radar_driver_task")));
172 static int radar_feature_task_weakref(void *param) __attribute__ ((weakref("radar_feature_task")));
173 static int radar_demo_init_weakref(void *param) __attribute__ ((weakref("radar_demo_init")));
174 static void at_radar_cmd_register_weakref(void) __attribute__ ((weakref("at_radar_cmd_register")));
175
176 #endif
177 #ifdef WIFI_TASK_EXIST
178 static void at_sys_cmd_register_weakref(void) __attribute__ ((weakref("at_sys_cmd_register")));
179 #endif
180
181 #ifdef BTH_TASK_EXIST
182 static void at_bt_cmd_register_weakref(void) __attribute__ ((weakref("at_bt_cmd_register")));
183 void bt_acore_task_main(void);
184 void bt_tran_task_queue_init(void);
185 void recv_data_task(void);
186 void btsrv_task_body(const void *data);
187 void sdk_msg_thread(void);
188 #endif
189 #ifndef CHIP_EDA
190 static void app_main(const void *unused);
191 #endif
192 static const app_task_definition_t g_app_tasks[] = {
193 #ifndef CHIP_EDA
194 {"app", APP_STACK_SIZE, TASK_PRIORITY_APP, (osal_kthread_handler)app_main},
195 #endif
196 #ifdef TEST_SUITE
197 {"cmd_loop", TESTSUITE_STACK_SIZE, TASK_PRIORITY_CMD, (osal_kthread_handler)cmd_processor_entry},
198 #endif
199 #ifdef HSO_SUPPORT
200 {"log", HSO_STACK_SIZE, TASK_PRIORITY_LOG, (osal_kthread_handler)log_main},
201 #endif
202 #ifdef BGLE_TASK_EXIST
203 #ifdef SPARKLYZER_ACTIVATED
204 {"bt", BT_STACK_SIZE, TASK_PRIORITY_BT, (osal_kthread_handler)splz_thread_handle},
205 #else
206 {"bt", BT_STACK_SIZE, TASK_PRIORITY_BT, (osal_kthread_handler)bt_thread_handle},
207 #endif
208 #endif
209 #ifdef BTH_TASK_EXIST
210 {"bt_sdk", BT_SDK_STACK_SIZE, TASK_PRIORITY_SDK, (osal_kthread_handler)bt_acore_task_main},
211 {"bth_sdk", BTH_SDK_STACK_SIZE, TASK_PRIORITY_BTH_SDK, (osal_kthread_handler)sdk_msg_thread},
212 {"recvBthDataTask", BTH_RECV_STACK_SIZE, TASK_PRIORITY_BTH_RECV, (osal_kthread_handler)recv_data_task},
213 { "bt_service", BTH_SERVICE_STACK_SIZE, TASK_PRIORITY_SRV, (osal_kthread_handler)btsrv_task_body},
214 #endif
215 #ifdef AT_COMMAND
216 {"at", AT_STACK_SIZE, TASK_PRIORITY_CMD, (osal_kthread_handler)uapi_at_msg_main},
217 #endif
218 #ifndef DEVICE_BGLE_ALL
219 #ifdef WIFI_TASK_EXIST
220 /* 栈大小待确认 任务优先级待确认 */
221 {"wifi", WIFI_STACK_SIZE, TASK_PRIORITY_WF, (osal_kthread_handler)wifi_host_task},
222 #endif
223 #ifdef CONFIG_RADAR_SERVICE
224 {"radar_driver", RADAR_STACK_SIZE_D, TASK_PRIORITY_RD_D, (osal_kthread_handler)radar_driver_task_weakref},
225 {"radar_feature", RADAR_STACK_SIZE_F, TASK_PRIORITY_RD_F, (osal_kthread_handler)radar_feature_task_weakref},
226 {"radar_demo", RADAR_STACK_SIZE, TASK_PRIORITY_RD_F, (osal_kthread_handler)radar_demo_init_weakref},
227 #endif
228 #endif
229 #ifdef CONFIG_SUPPORT_HILINK
230 {"hilink", WIFI_STACK_SIZE, TASK_PRIORITY_WF, (osal_kthread_handler)hilink_entry},
231 #endif
232 };
233
234 static void systick_cali_xclk_bottom_half(void);
235
236 #define APP_MAIN_DELAY_TIME 1000 /* 1000 tick，1 tick=10ms，共10s */
237 #define M_NUM_TASKS (sizeof(g_app_tasks) / sizeof(app_task_definition_t))
238 #define PATCH_NUM 194
239 #define PATCH_REMAP_TAB_WORD_NUM 2
240 #define PATCH_CMP_HEADINFO_NUM 3
241 static uint32_t patch_remap[PATCH_NUM * PATCH_REMAP_TAB_WORD_NUM] __attribute__((section(".patch_remap"))) = { 0 };
242 static uint32_t patch_cmp[PATCH_NUM + PATCH_CMP_HEADINFO_NUM] __attribute__((section(".patch_cmp"))) = { 0 };
243
patch_init(void)244 static void patch_init(void)
245 {
246 riscv_cfg_t patch_cfg;
247 patch_cfg.cmp_start_addr = (uint32_t)(uintptr_t)((void*)patch_cmp);
248 patch_cfg.remap_addr = (uint32_t)(uintptr_t)((void*)patch_remap);
249 patch_cfg.off_region = true;
250 patch_cfg.flplacmp0_en = 0;
251 patch_cfg.flplacmp1_en = 0;
252 riscv_patch_init(patch_cfg);
253 }
254
255 static uint32_t g_at_uart_recv_cnt = 0;
256 #ifndef CHIP_EDA
app_main(const void * unused)257 static void app_main(const void *unused)
258 {
259 LOS_MEM_POOL_STATUS status;
260 UNUSED(unused);
261 (void)osDelay(100); // 100: 100tiks = 1s
262 systick_cali_xclk_bottom_half();
263 while (1) {
264 (void)osDelay(APP_MAIN_DELAY_TIME);
265 LOS_MemInfoGet(m_aucSysMem0, &status);
266 PRINT("[SYS INFO] mem: used:%u, free:%u; log: drop/all[%u/%u], at_recv %u.\r\n", status.uwTotalUsedSize,
267 status.uwTotalFreeSize, log_get_missed_messages_count(), log_get_all_messages_count(), g_at_uart_recv_cnt);
268 }
269 }
270 #endif
271
272 #ifdef TEST_SUITE
cmd_processor_entry(void * args)273 static void cmd_processor_entry(void *args)
274 {
275 UNUSED(args);
276 uapi_test_suite_init();
277 test_suite_main_add_functions();
278 }
279 #endif
280
main_initialise(const void * unused1,uint32_t unused2)281 static void main_initialise(const void *unused1, uint32_t unused2)
282 {
283 osal_task *task_handle = NULL;
284 UNUSED(unused1);
285 UNUSED(unused2);
286 osal_kthread_lock();
287 for (uint32_t i = 0; i < (sizeof(g_app_tasks) / sizeof(g_app_tasks[0])); i++) {
288 if (g_app_tasks[i].func == NULL) {
289 PRINT("WARNING: main_initialise::thread[%d] func is null\r\n", i);
290 continue;
291 }
292 task_handle = osal_kthread_create(g_app_tasks[i].func, NULL, g_app_tasks[i].name, g_app_tasks[i].stack_size);
293 if (task_handle == NULL) {
294 PRINT("ERROR: main_initialise::osal_kthread_create[%d] [%s] failed\r\n", i, g_app_tasks[i].name);
295 continue;
296 }
297 if (osal_kthread_set_priority(task_handle, g_app_tasks[i].priority) != OSAL_SUCCESS) {
298 PRINT("ERROR: main_initialise::osal_kthread_set_priority[%d] failed\r\n", i);
299 }
300 }
301 osal_kthread_unlock();
302 }
303
304 #ifdef TEST_SUITE
test_fun(int argc,const char * argv[])305 static int test_fun(int argc, const char *argv[])
306 {
307 UNUSED(argc);
308 UNUSED(argv);
309 PRINT("Test Hso Last Dump\r\n");
310 WRITE_UINT32(0x0, 0x0);
311 return 0;
312 }
313
test_suite_main_add_functions(void)314 static void test_suite_main_add_functions(void)
315 {
316 add_auxiliary_functions();
317 uapi_test_suite_add_function("test_fun", "Test functions", (test_suite_function_callback_t)test_fun);
318 }
319 #endif
320
321 static const sfc_flash_config_t sfc_cfg = {
322 .read_type = FAST_READ_QUAD_OUTPUT,
323 .write_type = PAGE_PROGRAM,
324 .mapping_addr = 0x200000,
325 .mapping_size = 0x800000,
326 };
327
328 #ifdef BOARD_ASIC
bypass_uart_auto_gate(void)329 static void bypass_uart_auto_gate(void)
330 {
331 #define IP_AUTO_CG_BYPASS 0x44000244
332 #define BIT_UART0_CK_EN_HW 10
333 #define BIT_UART1_CK_EN_HW 11
334 #define BIT_UART2_CK_EN_HW 12
335 #define BIT_UART0_AUTO_CG_BYPASS 0
336 #define BIT_UART1_AUTO_CG_BYPASS 1
337 #define BIT_UART2_AUTO_CG_BYPASS 2
338 // bypass uart auto gate
339 reg_setbit(IP_AUTO_CG_BYPASS, 0, BIT_UART0_CK_EN_HW);
340 reg_setbit(IP_AUTO_CG_BYPASS, 0, BIT_UART1_CK_EN_HW);
341 reg_setbit(IP_AUTO_CG_BYPASS, 0, BIT_UART2_CK_EN_HW);
342 reg_setbit(IP_AUTO_CG_BYPASS, 0, BIT_UART0_AUTO_CG_BYPASS);
343 reg_setbit(IP_AUTO_CG_BYPASS, 0, BIT_UART1_AUTO_CG_BYPASS);
344 reg_setbit(IP_AUTO_CG_BYPASS, 0, BIT_UART2_AUTO_CG_BYPASS);
345 }
346 #endif
347
348 /* 利用tcxo校准systick */
349 static uint64_t systick_count1;
350 static uint64_t tcxo_count1;
351
systick_cali_xclk_upper_half(void)352 static void systick_cali_xclk_upper_half(void)
353 {
354 uint32_t irq_sts = osal_irq_lock();
355 systick_count1 = uapi_systick_get_count();
356 tcxo_count1 = uapi_tcxo_get_us();
357 osal_irq_restore(irq_sts);
358 }
359
systick_cali_xclk_bottom_half(void)360 static void systick_cali_xclk_bottom_half(void)
361 {
362 uint32_t cali_clock;
363 uint64_t systick_count2;
364 uint64_t tcxo_count2;
365
366 uint32_t irq_sts = osal_irq_lock();
367 systick_count2 = uapi_systick_get_count();
368 tcxo_count2 = uapi_tcxo_get_us();
369 osal_irq_restore(irq_sts);
370
371 /*
372 * Increase of actual systic_count Increase of us count
373 * (systick_count2 - systick_count1) (tcxo_count2 - tcxo_count1)
374 * -------------------------------- = ---------------------------
375 * g_systick_clock 10000000us(1s)
376 *
377 * 1000000.0: 使用浮点计算中间结果
378 */
379 cali_clock = (uint32_t)(((systick_count2 - systick_count1) * 1000000.0) /
380 (tcxo_count2 - tcxo_count1));
381 systick_clock_set(cali_clock);
382 }
383
hw_init(void)384 static void hw_init(void)
385 {
386 #ifdef BOARD_ASIC
387 open_rf_power();
388 switch_clock();
389 bypass_uart_auto_gate();
390 #endif
391 uapi_pin_init();
392 uapi_gpio_init();
393 #ifdef SW_UART_DEBUG
394 sw_debug_uart_init(CONFIG_DEBUG_UART_BAUDRATE);
395 PRINT("Debug uart init succ.\r\n");
396 #endif
397 uapi_timer_init();
398 uapi_timer_adapter(1, TIMER_1_IRQN, irq_prio(TIMER_1_IRQN));
399 uapi_systick_init();
400 uapi_tcxo_init();
401 systick_cali_xclk_upper_half();
402 // 软件初始化watchdog
403 uapi_watchdog_init(WDT_TIMEOUT_S);
404 uapi_watchdog_set_time(WDT_TIMEOUT_S);
405 uapi_watchdog_enable(WDT_MODE_INTERRUPT);
406 set_efuse_period();
407 uapi_efuse_init(); // efuse函数初始化
408
409 uapi_sfc_init((sfc_flash_config_t *)&sfc_cfg);
410
411 #if defined(CONFIG_PM_SUPPORT_POWER_EXCEPTION_DEBUG) && (CONFIG_PM_SUPPORT_POWER_EXCEPTION_DEBUG == 1)
412 pm_pwr_dbg_init();
413 #endif
414
415 uapi_tsensor_init();
416 // 默认采样周期为 0xFFFF 个32K时钟
417 uapi_tsensor_start_inquire_mode(TSENSOR_SAMP_MODE_AVERAGE_CYCLE, 0xFFFF);
418 uapi_drv_cipher_env_init();
419 #ifdef CONFIG_MIDDLEWARE_SUPPORT_NV
420 uapi_nv_init();
421 #if defined(CONFIG_OTA_UPDATE_SUPPORT)
422 #if (defined(CONFIG_NV_SUPPORT_OTA_UPDATE) && (defined(NV_YES)) && (CONFIG_NV_SUPPORT_OTA_UPDATE == NV_YES))
423 (void)ws63_upg_init();
424 (void)uapi_drv_cipher_hash_init();
425 (void)nv_upg_upgrade_task_process();
426 #endif
427 #endif
428 #endif
429 #ifdef WIFI_TASK_EXIST
430 init_dev_addr();
431 #endif
432 cmu_xo_trim_init();
433 #if defined(CONFIG_MIDDLEWARE_SUPPORT_NV)
434 // 频偏温补默认不开启 因此没有支持nv则不会开启该功能 注:需要在读取完efuse值之后执行
435 cmu_xo_trim_temp_comp_init();
436 #endif
437 }
438
439 #ifdef AT_COMMAND
440 #define CRLF_STR "\r\n"
441 #define CR_ASIC_II 0xD
442 #define AT_RX_BUFFER_SIZE 16
443
444 static uint8_t g_at_test_uart_rx_buffer_test[AT_RX_BUFFER_SIZE];
445
at_write_func(const char * data)446 static void at_write_func(const char *data)
447 {
448 uapi_uart_write(AT_UART_BUS, (const uint8_t *)data, strlen(data), 0);
449 }
450 static uint8_t g_at_pre_char = 0;
at_uart_rx_callback(const void * buffer,uint16_t length,bool error)451 static void at_uart_rx_callback(const void *buffer, uint16_t length, bool error)
452 {
453 errcode_t ret;
454 const uint8_t *data = (const uint8_t *)buffer;
455 if (error) {
456 osal_printk("*******uart error*******\r\n");
457 }
458 #ifndef CHIP_EDA
459 if (length == 0) {
460 panic(PANIC_TESTSUIT, __LINE__);
461 }
462 #endif
463 g_at_uart_recv_cnt += length;
464 if (((char *)buffer)[0] == CR_ASIC_II) {
465 uapi_uart_write(AT_UART_BUS, (uint8_t *)CRLF_STR, (uint16_t)strlen(CRLF_STR), 0);
466 } else {
467 uapi_uart_write(AT_UART_BUS, (const uint8_t *)buffer, (uint32_t)length, 0);
468 }
469 ret = uapi_at_channel_data_recv(AT_UART_PORT, (uint8_t *)buffer, (uint32_t)length);
470 if (ret != ERRCODE_SUCC) {
471 /* 前一个字符为'\r'时单独一个'\n'导致的CHANNEL_BUSY不打印 */
472 if (g_at_pre_char != '\r' || length != 1 || data[0] != '\n' || ret != ERRCODE_AT_CHANNEL_BUSY) {
473 osal_printk("\r\nat_uart_rx_callback fail:0x%x\r\n", ret);
474 }
475 }
476 g_at_pre_char = data[length - 1];
477 }
478
at_uart_init(void)479 void at_uart_init(void)
480 {
481 uart_buffer_config_t uart_buffer_config;
482 uart_pin_config_t uart_pin_config = {
483 .tx_pin = 0,
484 .rx_pin = 0,
485 .cts_pin = PIN_NONE,
486 .rts_pin = PIN_NONE
487 };
488 uart_attr_t uart_line_config = {
489 .baud_rate = CONFIG_AT_UART_BAUDRATE,
490 .data_bits = UART_DATA_BIT_8,
491 .stop_bits = UART_STOP_BIT_1,
492 .parity = UART_PARITY_NONE
493 };
494 uart_buffer_config.rx_buffer_size = AT_RX_BUFFER_SIZE;
495 uart_buffer_config.rx_buffer = g_at_test_uart_rx_buffer_test;
496 uapi_uart_deinit(AT_UART_BUS);
497 (void)uapi_uart_init(AT_UART_BUS, &uart_pin_config, &uart_line_config, NULL, &uart_buffer_config);
498 (void)uapi_uart_register_rx_callback(AT_UART_BUS, UART_RX_CONDITION_FULL_OR_SUFFICIENT_DATA_OR_IDLE,
499 AT_RX_BUFFER_SIZE, at_uart_rx_callback);
500 }
501
at_base_api_queue_create(uint32_t msg_count,uint32_t msg_size,unsigned long * queue_id)502 static void at_base_api_queue_create(uint32_t msg_count, uint32_t msg_size, unsigned long *queue_id)
503 {
504 osal_msg_queue_create(NULL, (uint16_t)msg_count, queue_id, 0, (uint16_t)msg_size);
505 }
506
at_base_api_msg_queue_write(unsigned long queue_id,void * msg_ptr,uint32_t msg_size,uint32_t timeout)507 static uint32_t at_base_api_msg_queue_write(unsigned long queue_id, void *msg_ptr,
508 uint32_t msg_size, uint32_t timeout)
509 {
510 return (uint32_t)osal_msg_queue_write_copy(queue_id, msg_ptr, msg_size, timeout);
511 }
512
at_base_api_msg_queue_read(unsigned long queue_id,void * buf_ptr,uint32_t * buf_size,uint32_t timeout)513 static uint32_t at_base_api_msg_queue_read(unsigned long queue_id, void *buf_ptr,
514 uint32_t *buf_size, uint32_t timeout)
515 {
516 return (uint32_t)osal_msg_queue_read_copy(queue_id, buf_ptr, buf_size, timeout);
517 }
518
at_base_api_task_pause(void)519 static void at_base_api_task_pause(void)
520 {
521 osal_yield();
522 }
523
at_base_api_malloc(uint32_t size)524 static void* at_base_api_malloc(uint32_t size)
525 {
526 return osal_kmalloc(size, OSAL_GFP_ATOMIC);
527 }
528
at_base_api_free(void * addr)529 static void at_base_api_free(void *addr)
530 {
531 osal_kfree(addr);
532 }
533
at_base_api_register(void)534 static void at_base_api_register(void)
535 {
536 at_base_api_t base_api = {
537 .msg_queue_create_func = at_base_api_queue_create,
538 .msg_queue_write_func = at_base_api_msg_queue_write,
539 .msg_queue_read_func = at_base_api_msg_queue_read,
540 .task_pause_func = at_base_api_task_pause,
541 .malloc_func = at_base_api_malloc,
542 .free_func = at_base_api_free,
543 };
544 uapi_at_base_api_register(base_api);
545 }
546 #endif
547
cpu_cache_init(void)548 static void cpu_cache_init(void)
549 {
550 ArchICacheFlush();
551 ArchDCacheInvalidate();
552 ArchICacheEnable(CACHE_32KB);
553 ArchICachePrefetchEnable(CACHE_PREF_1_LINES);
554 ArchDCacheEnable(CACHE_4KB);
555 return;
556 }
557
558 #ifdef LOG_SUPPORT
559 uint32_t *g_hso_buff = NULL;
get_hso_buff(void)560 uint32_t get_hso_buff(void)
561 {
562 return (uint32_t)g_hso_buff;
563 }
564 #endif
565
sys_fault_handler(uint32_t exc_type,exc_context_t * exc_buff_addr)566 static void sys_fault_handler(uint32_t exc_type, exc_context_t *exc_buff_addr)
567 {
568 (void)OsDbgTskInfoGet(OS_ALL_TASK_MASK);
569 OsExcStackInfo();
570 do_fault_handler(exc_type, exc_buff_addr);
571 }
572
573 #ifdef AT_COMMAND
at_custom_cmd_register(void)574 __attribute__((weak)) void at_custom_cmd_register(void)
575 {
576 return;
577 }
578
do_at_cmd_register(void)579 static void do_at_cmd_register(void)
580 {
581 at_custom_cmd_register();
582 #ifdef CONFIG_AT_SUPPORT_PLT
583 at_plt_cmd_register();
584 #endif
585 #ifdef WIFI_TASK_EXIST
586 if (at_sys_cmd_register_weakref != NULL) {
587 at_sys_cmd_register_weakref();
588 }
589 #endif
590 #ifdef BTH_TASK_EXIST
591 if (at_bt_cmd_register_weakref != NULL) {
592 at_bt_cmd_register_weakref();
593 }
594 #endif
595 #ifdef CONFIG_RADAR_SERVICE
596 if (at_radar_cmd_register_weakref != NULL) {
597 at_radar_cmd_register_weakref();
598 }
599 #endif
600 }
601 #endif
602
OHOS_SystemInit(void)603 __attribute__((weak)) void OHOS_SystemInit(void)
604 {
605 return;
606 }
main(void)607 LITE_OS_SEC_TEXT_INIT int main(void)
608 {
609 patch_init();
610 uapi_partition_init();
611 pmp_enable();
612 cpu_cache_init();
613 #ifdef BOARD_ASIC
614 // 在OS启动之前设置工作时钟
615 set_uart_tcxo_clock_period();
616 #endif
617 ArchSetExcHook((EXC_PROC_FUNC)sys_fault_handler);
618 LOS_PrepareMainTask();
619 g_kernel_state = osKernelInitialize();
620 hw_init();
621 #ifdef CONFIG_PM_SUPPORT_SRV_DECOUPLING
622 pm_porting_init();
623 #endif
624 #ifdef CONFIG_MEMORY_CUSTOMIZE_RSV
625 // 硬件初始化完成后，提前擦除，方便后续重启前写入
626 reboot_mem_flash_erase();
627 #endif
628
629 #ifdef MBEDTLS_HARDEN_OPEN
630 (void)mbedtls_adapt_register_func();
631 #endif
632 #if defined(TEST_SUITE) // testsuite是平台用于跑测试，正常业务版本(包括BGLE DEVICE ONLY)不需要打开。
633 uapi_uart_deinit(TEST_SUITE_UART_BUS);
634 test_suite_uart_init();
635 #elif defined(DEVICE_ONLY) // 这个宏指的是BGLE DEVICE ONLY
636 wvt_uart_init();
637 const uint8_t str1[] = "DEVICE_ONLY UART INIT SUCC!\r\n";
638 uapi_uart_write(UART_BUS_2, str1, sizeof(str1), 0);
639 #endif
640 #ifdef AT_COMMAND
641 at_uart_init();
642 PRINT("AT uart init succ.\r\n");
643 at_base_api_register();
644 uapi_at_channel_write_register(AT_UART_PORT, at_write_func);
645 #ifdef CONFIG_AT_SUPPORT_ZDIAG
646 zdiag_at_init();
647 #endif
648 do_at_cmd_register();
649 #endif
650 #ifdef LOG_SUPPORT
651 g_hso_buff = (uint32_t *)osal_kmalloc(LOGGING_REGION_LENGTH, 0);
652 log_memory_region_init();
653 log_init();
654 log_oml_ota_init();
655 log_oam_status_store_init();
656 log_uart_init_after_rtos();
657 log_uart_port_init();
658 const uint8_t str2[] = "HSO UART INIT SUCC!\r\n";
659 uapi_uart_write(LOG_UART_BUS, str2, sizeof(str2), 0);
660 #endif
661 #ifdef HSO_SUPPORT
662 dfx_system_init();
663 hal_register_exception_dump_callback(log_exception_dump);
664 #endif
665 #ifdef CONFIG_MIDDLEWARE_SUPPORT_LFS
666 PRINT("=========FS MOUNT=========\r\n");
667 fs_adapt_mount();
668 PRINT("=========FS READY=========\r\n");
669 #endif
670
671 main_initialise(NULL, 0);
672
673 OHOS_SystemInit();
674 app_tasks_init();
675
676 /* Start LiteOS */
677 (void)osKernelStart();
678 /* jump to main() in asm, so ra is main(), return will loop main() */
679 for (;;) {}
680 return 0;
681 }
682
683 /* copy ram */
copy_bin_to_ram(unsigned int * start_addr,const unsigned int * const load_addr,unsigned int size)684 __attribute__((section(".text.runtime.init"))) void copy_bin_to_ram(unsigned int *start_addr,
685 const unsigned int *const load_addr, unsigned int size)
686 {
687 unsigned int i;
688
689 for (i = 0; i < size / sizeof(unsigned int); i++) {
690 *(start_addr + i) = *(load_addr + i);
691 }
692 }
693
694 /* init ram value */
init_mem_value(unsigned int * start_addr,const unsigned int * const end_addr,unsigned int init_val)695 __attribute__((section(".text.runtime.init"))) void init_mem_value(unsigned int *start_addr,
696 const unsigned int *const end_addr, unsigned int init_val)
697 {
698 unsigned int *dest = start_addr;
699
700 while (dest < end_addr) {
701 *dest = init_val;
702 dest++;
703 }
704 }
705
706 #ifdef CONFIG_MEMORY_CUSTOMIZE_RSV
707 #define REG_SYS_RST_RECORD 0x40000098
708 #define SYS_SOFT_RST (0x1 << 1)
709 #define SYS_WDT_RST (0x1 << 0)
710 #define MEM_NEED_RESUME 1
711
712 /* Determine whether resume is required */
is_resume_required(void)713 __attribute__((section(".text.runtime.init"))) int is_resume_required(void)
714 {
715 unsigned int sys_rst_record_val = *((unsigned int *)REG_SYS_RST_RECORD);
716
717 if (sys_rst_record_val & (SYS_WDT_RST | SYS_SOFT_RST)) {
718 return MEM_NEED_RESUME;
719 }
720 return 0;
721 }
722
723 #endif
724
do_relocation(void)725 __attribute__((section(".text.runtime.init"))) void do_relocation(void)
726 {
727 /* copy rom_data from flash to DTCM */
728 copy_bin_to_ram(&__rom_data_begin__, &__rom_data_load__, (unsigned int)&__rom_data_size__);
729 /* clear rom_bss on DTCM */
730 init_mem_value(&__rom_bss_begin__, &__rom_bss_end__, 0);
731
732 /* copy rom_patch from flash to ITCM */
733 copy_bin_to_ram(&__rom_patch_begin__, &__rom_patch_load__, (unsigned int)&__rom_patch_size__);
734
735 /* copy tcm_text from flash to ITCM */
736 copy_bin_to_ram(&__tcm_text_begin__, &__tcm_text_load__, (unsigned int)&__tcm_text_size__);
737 /* copy tcm_data from flash to DTCM */
738 copy_bin_to_ram(&__tcm_data_begin__, &__tcm_data_load__, (unsigned int)&__tcm_data_size__);
739 /* clear tcm_bss on DTCM */
740 init_mem_value(&__tcm_bss_begin__, &__tcm_bss_end__, 0);
741
742 /* copy sram_text from flash to SRAM */
743 copy_bin_to_ram(&__sram_text_begin__, &__sram_text_load__, (unsigned int)&__sram_text_size__);
744
745 /* copy data from flash to SRAM */
746 copy_bin_to_ram(&__data_begin__, &__data_load__, (unsigned int)&__data_size__);
747
748 #ifdef CONFIG_MEMORY_CUSTOMIZE_RSV
749 if (is_resume_required() == MEM_NEED_RESUME) {
750 /* copy saved data from flash to SRAM */
751 copy_bin_to_ram(&__mem_rsv_begin__, &__mem_rsv_load__, (unsigned int)&__mem_rsv_size__);
752 } else {
753 /* clear rsv mem */
754 init_mem_value(&__mem_rsv_begin__, &__mem_rsv_end__, 0);
755 }
756 #endif
757
758 /* clear bss on SRAM */
759 init_mem_value(&__bss_begin__, &__bss_end__, 0);
760
761 return;
762 }
763
runtime_init(void)764 __attribute__((section(".text.runtime.init"))) void runtime_init(void)
765 {
766 dyn_mem_cfg();
767 #ifndef CHIP_EDA
768 do_relocation();
769 #endif
770 /* Jump to main */
771 main();
772 }
773