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 * Description: LOG oam message MODULE
15 * Author:
16 * Create:
17 */
18
19 #include "product.h"
20 #include "non_os.h"
21 #include "dfx_feature_config.h"
22 #if SYS_DEBUG_MODE_ENABLE == YES
23 #include "debug_print.h"
24 #include "log_printf.h"
25 #include "log_def.h"
26 #include "securec.h"
27 #include "log_oam_reg_query.h"
28 #include "log_oam_mem_query.h"
29 #include "oal_interface.h"
30 #include "log_oam_msg.h"
31 #if CORE != CONTROL_CORE
32 #ifdef HSO_SUPPORT
33 #include "dfx_channel.h"
34 #endif
35 #endif
36
37 #if (defined CONFIG_DFX_SUPPORT_CUSTOM_LOG) && (CONFIG_DFX_SUPPORT_CUSTOM_LOG == DFX_YES)
38 #include "dfx_adapt_typedef.h"
39 #endif
40
41 #define BT_DFT_RETURN_NEWLINE_LEN 2
42 #define BT_DFT_CMD_COMMA_LEN 1
43 #define BT_DFT_CMD_WR_INDEX 0
44 #define BT_DFT_CMD_WR_LEN 1
45 #define BT_DFT_CMD_REGMEM_SIZE_INDEX (BT_DFT_CMD_WR_INDEX + BT_DFT_CMD_WR_LEN + BT_DFT_CMD_COMMA_LEN)
46 #define BT_DFT_CMD_REGMEM_SIZE_LEN 1
47 #define BT_DFT_CMD_REGMEM_ADDR_INDEX (BT_DFT_CMD_REGMEM_SIZE_INDEX + BT_DFT_CMD_REGMEM_SIZE_LEN + BT_DFT_CMD_COMMA_LEN)
48 #define BT_DFT_CMD_REGMEM_ADDR_LEN 8
49 #define BT_DFT_CMD_REGMEM_VALUE_INDEX (BT_DFT_CMD_REGMEM_ADDR_INDEX + BT_DFT_CMD_REGMEM_ADDR_LEN + BT_DFT_CMD_COMMA_LEN)
50
51 #ifndef HSO_SUPPORT
52 static oml_rx_data_stru_t g_log_oam_rx_buffer[LOG_OAM_RX_BUFF_NUM];
53 #endif
54 static oam_cmd_handle_callback g_log_oam_log_config_callback = NULL;
55 static oam_cmd_handle_callback g_log_oml_mem_command_callback = NULL;
56 static oam_cmd_handle_callback g_log_oml_reg_command_callback = NULL;
57 static oam_cmd_handle_callback g_log_oml_ssi_reg_command_callback = NULL;
58 static oam_cmd_handle_callback g_log_oml_msg_cs_stat_callback = NULL;
59 static oam_cmd_handle_callback g_log_oml_btc_oam_callback = NULL;
60 static oam_cmd_handle_callback g_log_oml_bth_oam_callback = NULL;
61 static oam_cmd_handle_callback g_log_oml_app_oam_callback = NULL;
62 static oam_cmd_handle_callback g_log_oml_hifi_oam_callback = NULL;
63 static oam_cmd_handle_callback g_log_oml_reg32_command_callback = NULL;
64 static oam_cmd_handle_callback g_log_oml_ssi_block_callback = NULL;
65
convert_hex_str_2_uint8(uint8_t data)66 static uint8_t convert_hex_str_2_uint8(uint8_t data)
67 {
68 uint8_t result;
69
70 if ((data >= '0') && (data <= '9')) {
71 result = data - '0';
72 } else if ((data >= 'A') && (data <= 'F')) {
73 result = data - 'A' + 10; // Convert A-F to 10-15
74 } else {
75 result = 0;
76 }
77
78 return result;
79 }
80
get_uint8_from_at_cmd(const uint8_t * data,uint32_t data_index)81 static uint8_t get_uint8_from_at_cmd(const uint8_t *data, uint32_t data_index)
82 {
83 uint8_t result = 0;
84
85 result += convert_hex_str_2_uint8(data[data_index + 0]) << 4; /* Convert str[0] to bit[7:4] of uint8_t */
86 result += convert_hex_str_2_uint8(data[data_index + 1]) << 0; // Convert str[1] to bit[3:0] of uint8_t
87
88 return result;
89 }
90
get_uint16_from_at_cmd(const uint8_t * data,uint32_t data_index)91 static uint16_t get_uint16_from_at_cmd(const uint8_t *data, uint32_t data_index)
92 {
93 uint16_t result = 0;
94
95 result += convert_hex_str_2_uint8(data[data_index + 0]) << 12; /* Convert str[0] to bit[15:12] of uint16 */
96 result += convert_hex_str_2_uint8(data[data_index + 1]) << 8; // Convert str[1] to bit[11:8] of uint16
97 result += convert_hex_str_2_uint8(data[data_index + 2]) << 4; // Convert str[2] to bit[7:4] of uint16
98 result += convert_hex_str_2_uint8(data[data_index + 3]) << 0; // Convert str[3] to bit[3:0] of uint16
99
100 return result;
101 }
102
get_uint32_from_at_cmd(const uint8_t * data,uint32_t data_index)103 static uint32_t get_uint32_from_at_cmd(const uint8_t *data, uint32_t data_index)
104 {
105 uint32_t result = 0;
106
107 result += convert_hex_str_2_uint8(data[data_index + 0]) << 28; /* Convert str[0] to bit[31:28] of uint32 */
108 result += convert_hex_str_2_uint8(data[data_index + 1]) << 24; /* Convert str[1] to bit[27:24] of uint32 */
109 result += convert_hex_str_2_uint8(data[data_index + 2]) << 20; // Convert str[2] to bit[23:20] of uint32
110 result += convert_hex_str_2_uint8(data[data_index + 3]) << 16; // Convert str[3] to bit[19:16] of uint32
111 result += convert_hex_str_2_uint8(data[data_index + 4]) << 12; // Convert str[4] to bit[15:12] of uint32
112 result += convert_hex_str_2_uint8(data[data_index + 5]) << 8; // Convert str[5] to bit[11:8] of uint32
113 result += convert_hex_str_2_uint8(data[data_index + 6]) << 4; // Convert str[6] to bit[7:4] of uint32
114 result += convert_hex_str_2_uint8(data[data_index + 7]) << 0; // Convert str[7] to bit[3:0] of uint32
115
116 return result;
117 }
118
119 #if (CORE != GNSS) && (CORE != CONTROL_CORE)
120 #ifndef HSO_SUPPORT
log_oam_store_buffer(const void * rx_buffer,uint16_t rx_buffer_length)121 static bool log_oam_store_buffer(const void *rx_buffer, uint16_t rx_buffer_length)
122 {
123 uint8_t loop;
124 uint8_t *cur_addr = NULL;
125 errno_t sec_ret;
126
127 for (loop = 0; loop < LOG_OAM_RX_BUFF_NUM; loop++) {
128 // If there is a message, exit and check weather is data to store.
129 if (g_log_oam_rx_buffer[loop].uc_buff_state == OML_BUFF_USED) {
130 continue;
131 }
132 // Current buffer have space to store the data
133 if (rx_buffer_length <= (LOG_OAM_RX_BUFF_LEN - g_log_oam_rx_buffer[loop].s_buff_used_len)) {
134 cur_addr = g_log_oam_rx_buffer[loop].auc_buff + g_log_oam_rx_buffer[loop].s_buff_used_len;
135 sec_ret = memcpy_s((void *)cur_addr, LOG_OAM_RX_BUFF_LEN - g_log_oam_rx_buffer[loop].s_buff_used_len,
136 rx_buffer, rx_buffer_length);
137 if (sec_ret != EOK) {
138 return false;
139 }
140 g_log_oam_rx_buffer[loop].s_buff_used_len += rx_buffer_length;
141 g_log_oam_rx_buffer[loop].uc_buff_state = OML_BUFF_USING;
142 return true;
143 } else {
144 g_log_oam_rx_buffer[loop].s_buff_used_len = 0;
145
146 // Clean the buffer and check again.
147 if (rx_buffer_length > (LOG_OAM_RX_BUFF_LEN - g_log_oam_rx_buffer[loop].s_buff_used_len)) {
148 return false;
149 }
150 cur_addr = g_log_oam_rx_buffer[loop].auc_buff + g_log_oam_rx_buffer[loop].s_buff_used_len;
151 sec_ret = memcpy_s((void *)cur_addr, LOG_OAM_RX_BUFF_LEN - g_log_oam_rx_buffer[loop].s_buff_used_len,
152 rx_buffer, rx_buffer_length);
153 if (sec_ret != EOK) {
154 return false;
155 }
156 g_log_oam_rx_buffer[loop].s_buff_used_len += rx_buffer_length;
157 g_log_oam_rx_buffer[loop].uc_buff_state = OML_BUFF_USING;
158 return true;
159 }
160 }
161 return false;
162 }
163
log_recv_data_handle(void)164 static void log_recv_data_handle(void)
165 {
166 uint8_t loop;
167 om_msg_header_stru_t *pst_oml_header = NULL;
168 non_os_enter_critical();
169 for (loop = 0; loop < LOG_OAM_RX_BUFF_NUM; loop++) {
170 // If this buff is already a complete message
171 if ((g_log_oam_rx_buffer[loop].uc_buff_state == OML_BUFF_USING) &&
172 (g_log_oam_rx_buffer[loop].s_buff_used_len > OM_FRAME_HEADER_LEN)) {
173 pst_oml_header = (om_msg_header_stru_t *)(g_log_oam_rx_buffer[loop].auc_buff);
174 if ((pst_oml_header->frame_start != OM_FRAME_DELIMITER) ||
175 (pst_oml_header->func_type >= OM_MSG_TYPE_BUTT)) {
176 g_log_oam_rx_buffer[loop].s_buff_used_len = 0;
177 g_log_oam_rx_buffer[loop].uc_buff_state = OML_BUFF_NOT_USED;
178 non_os_exit_critical();
179 return;
180 }
181 // Check received data length
182 if (pst_oml_header->frame_len > g_log_oam_rx_buffer[loop].s_buff_used_len) {
183 continue;
184 }
185 // Check end data
186 if (g_log_oam_rx_buffer[loop].auc_buff[pst_oml_header->frame_len - 1] == OM_FRAME_DELIMITER) {
187 g_log_oam_rx_buffer[loop].uc_buff_state = OML_BUFF_USED;
188 non_os_exit_critical();
189 return;
190 } else {
191 g_log_oam_rx_buffer[loop].s_buff_used_len = 0;
192 g_log_oam_rx_buffer[loop].uc_buff_state = OML_BUFF_NOT_USED;
193 }
194 }
195 }
196 non_os_exit_critical();
197 }
198 #endif
199 #endif
200
parse_reg_or_mem_cmd_operate(const uint8_t * data,uint32_t len,rw_reg_mem_cmd_t * reg_mem_cmd)201 uint32_t parse_reg_or_mem_cmd_operate(const uint8_t *data, uint32_t len, rw_reg_mem_cmd_t *reg_mem_cmd)
202 {
203 if (reg_mem_cmd == NULL || data == NULL) {
204 return OAM_ERR_POINT_NULL;
205 }
206
207 UNUSED(len);
208
209 /* Step1: Get the operation */
210 if (data[BT_DFT_CMD_WR_INDEX] == 'R') {
211 reg_mem_cmd->mode = REG_ACTION_READ;
212 } else if (data[BT_DFT_CMD_WR_INDEX] == 'W') {
213 reg_mem_cmd->mode = REG_ACTION_WRITE;
214 } else if (data[BT_DFT_CMD_WR_INDEX] == 'B') {
215 reg_mem_cmd->mode = MEM_ACTION_READ_BLOCK;
216 } else {
217 return OAM_ERR_OP_ERR;
218 }
219
220 return OAM_RET_OK;
221 }
222
parse_reg_or_mem_cmd_size(const uint8_t * data,uint32_t len,rw_reg_mem_cmd_t * reg_mem_cmd)223 uint32_t parse_reg_or_mem_cmd_size(const uint8_t *data, uint32_t len, rw_reg_mem_cmd_t *reg_mem_cmd)
224 {
225 if (reg_mem_cmd == NULL) {
226 return OAM_ERR_POINT_NULL;
227 }
228
229 UNUSED(len);
230
231 /* Step2: Get the reg or mem size */
232 if (data[BT_DFT_CMD_REGMEM_SIZE_INDEX] == 'L') {
233 reg_mem_cmd->reg_mem_size = (uint8_t)sizeof(uint32_t);
234 } else if (data[BT_DFT_CMD_REGMEM_SIZE_INDEX] == 'S') {
235 reg_mem_cmd->reg_mem_size = (uint8_t)sizeof(uint16_t);
236 } else if (data[BT_DFT_CMD_REGMEM_SIZE_INDEX] == 'U') {
237 reg_mem_cmd->reg_mem_size = (uint8_t)sizeof(uint8_t);
238 } else {
239 return OAM_ERR_SIZE_ERR;
240 }
241
242 return OAM_RET_OK;
243 }
244
parse_reg_or_mem_cmd_addr_value(const uint8_t * data,uint32_t len,rw_reg_mem_cmd_t * reg_mem_cmd)245 uint32_t parse_reg_or_mem_cmd_addr_value(const uint8_t *data, uint32_t len, rw_reg_mem_cmd_t *reg_mem_cmd)
246 {
247 if (reg_mem_cmd == NULL) {
248 return OAM_ERR_POINT_NULL;
249 }
250
251 UNUSED(len);
252
253 /* Step3: Get the register address */
254 reg_mem_cmd->reg_mem_addr_value[0] = get_uint32_from_at_cmd(data, BT_DFT_CMD_REGMEM_ADDR_INDEX);
255
256 /* Step4: Get the value */
257 if (reg_mem_cmd->reg_mem_size == sizeof(uint8_t)) {
258 reg_mem_cmd->reg_mem_addr_value[1] = get_uint8_from_at_cmd(data, BT_DFT_CMD_REGMEM_VALUE_INDEX);
259 } else if (reg_mem_cmd->reg_mem_size == sizeof(uint16_t)) {
260 reg_mem_cmd->reg_mem_addr_value[1] = get_uint16_from_at_cmd(data, BT_DFT_CMD_REGMEM_VALUE_INDEX);
261 } else if (reg_mem_cmd->reg_mem_size == sizeof(uint32_t)) {
262 reg_mem_cmd->reg_mem_addr_value[1] = get_uint32_from_at_cmd(data, BT_DFT_CMD_REGMEM_VALUE_INDEX);
263 } else {
264 return OAM_ERR_VALUE_ERR;
265 }
266
267 return OAM_RET_OK;
268 }
269
270 /* The handler of IPC_ACTION_AP_BT_HOOK_DATA */
271 #if (CORE_NUMS > 1) && defined IPC_NEW
272 #elif ((CORE_NUMS > 1) && (defined CONFIG_DFX_SUPPORT_CUSTOM_LOG) && (CONFIG_DFX_SUPPORT_CUSTOM_LOG == DFX_YES))
273 #elif (CORE_NUMS > 1)
ap_bt_hook_data_action_handler(ipc_action_t message,const volatile ipc_payload * payload_p,cores_t src,uint32_t id)274 bool ap_bt_hook_data_action_handler(ipc_action_t message, const volatile ipc_payload *payload_p,
275 cores_t src, uint32_t id)
276 {
277 uint8_t *command = (uint8_t *)payload_p->ap_bt_hook_data.command;
278 uint32_t command_len = payload_p->ap_bt_hook_data.command_len;
279
280 UNUSED(message);
281 UNUSED(id);
282 UNUSED(src);
283
284 oml_pf_log_print1(LOG_BCORE_PLT_LIB_LOG, LOG_NUM_LIB_LOG, LOG_LEVEL_INFO, "[INFO]:Start DFT with hook_type=%d",
285 (uint32_t)payload_p->ap_bt_hook_data.hook_type);
286 switch (payload_p->ap_bt_hook_data.hook_type) {
287 case HOOK_TYPE_REGS:
288 oml_reg_command(command, (uint16_t)command_len);
289 break;
290 case HOOK_TYPE_MEMS:
291 oml_mem_command(command, (uint16_t)command_len);
292 break;
293 case HOOK_TYPE_BLOCK_MEM:
294 oml_mem_command(command, (uint16_t)command_len);
295 break;
296 case HOOK_TYPE_SAMPLE_DATAS:
297 if (g_log_oml_btc_oam_callback) {
298 g_log_oml_btc_oam_callback(command, (uint16_t)command_len);
299 }
300 break;
301 case HOOK_TYPE_DISABLE_MEM_ACCESS:
302 break;
303 default:
304 break;
305 }
306
307 return true;
308 }
309
310 /* Send the result of start hooking to app core */
send_bt_ap_hook_data(ipc_bt_ap_hook_type_e hook_type,uint32_t addr,uint32_t len,uint32_t value)311 void send_bt_ap_hook_data(ipc_bt_ap_hook_type_e hook_type, uint32_t addr, uint32_t len, uint32_t value)
312 {
313 ipc_status_t ipc_returned_value;
314 ipc_payload_bt_ap_hook_data ipc_bt_ap_hook_data;
315
316 ipc_bt_ap_hook_data.hook_type = hook_type;
317 ipc_bt_ap_hook_data.addr = addr;
318 ipc_bt_ap_hook_data.len = len;
319 ipc_bt_ap_hook_data.value = value;
320
321 ipc_returned_value = ipc_spin_send_message_timeout(CORES_APPS_CORE,
322 IPC_ACTION_BT_AP_HOOK_DATA,
323 (ipc_payload *)&ipc_bt_ap_hook_data,
324 sizeof(ipc_payload_bt_ap_hook_data),
325 IPC_PRIORITY_LOWEST, false, IPC_SPIN_SEND_MAX_TIMEOUT);
326 if (ipc_returned_value != IPC_STATUS_OK) {
327 UNUSED(ipc_returned_value);
328 }
329 }
330 #endif
331
332 #if (CORE != GNSS) && (CORE != CONTROL_CORE) && (CORE != BT)
333 #ifndef HSO_SUPPORT
log_uart_clear_pending(void)334 static void log_uart_clear_pending(void)
335 {
336 if (uapi_uart_rx_fifo_is_empty(LOG_UART_BUS)) {
337 hal_uart_clear_pending(LOG_UART_BUS);
338 }
339 }
340 #endif
341
log_uart_rx_callback(const void * buffer,uint16_t length,bool remaining)342 void log_uart_rx_callback(const void *buffer, uint16_t length, bool remaining)
343 {
344 UNUSED(remaining);
345 #ifndef HSO_SUPPORT
346 if (log_oam_store_buffer((const void *)buffer, length) == true) {
347 log_recv_data_handle();
348 log_uart_clear_pending();
349 }
350 #else
351 diag_uart_rx_proc((uint8_t*)buffer, length);
352 #endif
353 }
354 #endif
355
log_oam_register_handler_callback(uint8_t message_type,oam_cmd_handle_callback callback)356 bool log_oam_register_handler_callback(uint8_t message_type, oam_cmd_handle_callback callback)
357 {
358 switch (message_type) {
359 case OM_MSG_TYPE_LOG:
360 g_log_oam_log_config_callback = callback;
361 break;
362 case OM_MSG_MEM_COMMAND:
363 g_log_oml_mem_command_callback = callback;
364 break;
365 case OM_MSG_REG_COMMAND:
366 g_log_oml_reg_command_callback = callback;
367 break;
368 case OM_MSG_SSI_REG_COMMAND:
369 g_log_oml_ssi_reg_command_callback = callback;
370 break;
371 case OM_MSG_CS_STAT_CMD:
372 g_log_oml_msg_cs_stat_callback = callback;
373 break;
374 case OM_MSG_TYPE_BTC_OAM:
375 g_log_oml_btc_oam_callback = callback;
376 break;
377 case OM_MSG_TYPE_BTH:
378 g_log_oml_bth_oam_callback = callback;
379 break;
380 case OM_MSG_TYPE_APP:
381 g_log_oml_app_oam_callback = callback;
382 break;
383 case OM_MSG_TYPE_HIFI:
384 g_log_oml_hifi_oam_callback = callback;
385 break;
386 case OM_MSG_REG32_COMMAND:
387 g_log_oml_reg32_command_callback = callback;
388 break;
389 case OM_MSG_SSIBLOCK_COMMAND:
390 g_log_oml_ssi_block_callback = callback;
391 break;
392 default:
393 return false;
394 }
395 return true;
396 }
397
log_oam_trigger_log_cb(uint8_t prime_id,uint8_t * data,uint16_t data_len)398 static void log_oam_trigger_log_cb(uint8_t prime_id, uint8_t *data, uint16_t data_len)
399 {
400 if ((prime_id == OM_LOG_CONFIG_REQ) && (g_log_oam_log_config_callback != NULL)) {
401 g_log_oam_log_config_callback(data, data_len);
402 }
403 }
404
log_oam_trigger_mem_cb(uint8_t * data,uint16_t data_len)405 static void log_oam_trigger_mem_cb(uint8_t *data, uint16_t data_len)
406 {
407 if (g_log_oml_mem_command_callback != NULL) {
408 g_log_oml_mem_command_callback(data, (uint8_t)data_len);
409 }
410 }
411
log_oam_trigger_reg_cb(uint8_t * data,uint16_t data_len)412 static void log_oam_trigger_reg_cb(uint8_t *data, uint16_t data_len)
413 {
414 if (g_log_oml_reg_command_callback != NULL) {
415 g_log_oml_reg_command_callback(data, (uint8_t)data_len);
416 }
417 }
418
log_oam_trigger_reg32_cb(uint8_t * data,uint16_t data_len)419 static void log_oam_trigger_reg32_cb(uint8_t *data, uint16_t data_len)
420 {
421 if (g_log_oml_reg32_command_callback != NULL) {
422 g_log_oml_reg32_command_callback(data, (uint8_t)data_len);
423 }
424 }
425
log_oam_trigger_ssi_reg_cb(uint8_t * data,uint16_t data_len)426 static void log_oam_trigger_ssi_reg_cb(uint8_t *data, uint16_t data_len)
427 {
428 if (g_log_oml_ssi_reg_command_callback != NULL) {
429 g_log_oml_ssi_reg_command_callback(data, (uint8_t)data_len);
430 }
431 }
432
log_oam_trigger_cs_stat_cb(uint8_t * data,uint16_t data_len)433 static void log_oam_trigger_cs_stat_cb(uint8_t *data, uint16_t data_len)
434 {
435 if (g_log_oml_msg_cs_stat_callback != NULL) {
436 g_log_oml_msg_cs_stat_callback(data, data_len);
437 }
438 }
439
log_oam_trigger_btc_oam_cb(uint8_t * data,uint16_t data_len)440 static void log_oam_trigger_btc_oam_cb(uint8_t *data, uint16_t data_len)
441 {
442 if (g_log_oml_btc_oam_callback != NULL) {
443 g_log_oml_btc_oam_callback(data + sizeof(om_msg_header_stru_t),
444 (data_len - sizeof(om_msg_header_stru_t)) - sizeof(uint8_t));
445 }
446 }
447
log_oam_trigger_bth_cb(uint8_t * data,uint16_t data_len)448 static void log_oam_trigger_bth_cb(uint8_t *data, uint16_t data_len)
449 {
450 if (g_log_oml_bth_oam_callback != NULL) {
451 g_log_oml_bth_oam_callback(data + sizeof(om_msg_header_stru_t),
452 (data_len - sizeof(om_msg_header_stru_t)) - sizeof(uint8_t));
453 }
454 }
455
log_oam_trigger_app_cb(uint8_t * data,uint16_t data_len)456 static void log_oam_trigger_app_cb(uint8_t *data, uint16_t data_len)
457 {
458 if (g_log_oml_app_oam_callback != NULL) {
459 g_log_oml_app_oam_callback(data + sizeof(om_msg_header_stru_t),
460 (data_len - sizeof(om_msg_header_stru_t)) - sizeof(uint8_t));
461 }
462 }
463
log_oam_trigger_hifi_cb(uint8_t * data,uint16_t data_len)464 static void log_oam_trigger_hifi_cb(uint8_t *data, uint16_t data_len)
465 {
466 if (g_log_oml_hifi_oam_callback != NULL) {
467 g_log_oml_hifi_oam_callback(data + sizeof(om_msg_header_stru_t),
468 (data_len - sizeof(om_msg_header_stru_t)) - sizeof(uint8_t));
469 }
470 }
471
log_oam_trigger_ssi_block_cb(uint8_t * data,uint16_t data_len)472 static void log_oam_trigger_ssi_block_cb(uint8_t *data, uint16_t data_len)
473 {
474 if (g_log_oml_ssi_block_callback != NULL) {
475 g_log_oml_ssi_block_callback(data, (uint8_t)data_len);
476 }
477 }
478
log_oam_trigger(const om_msg_header_stru_t * pst_oml_header,uint8_t prime_id,uint8_t * data,uint16_t data_len)479 static void log_oam_trigger(const om_msg_header_stru_t *pst_oml_header, uint8_t prime_id, uint8_t *data,
480 uint16_t data_len)
481 {
482 switch (pst_oml_header->func_type) {
483 case OM_MSG_TYPE_LOG:
484 log_oam_trigger_log_cb(prime_id, data, data_len);
485 break;
486 case OM_MSG_MEM_COMMAND:
487 log_oam_trigger_mem_cb(data, data_len);
488 break;
489 case OM_MSG_REG_COMMAND:
490 log_oam_trigger_reg_cb(data, data_len);
491 break;
492 case OM_MSG_SSI_REG_COMMAND:
493 log_oam_trigger_ssi_reg_cb(data, data_len);
494 break;
495 case OM_MSG_CS_STAT_CMD:
496 log_oam_trigger_cs_stat_cb(data, data_len);
497 break;
498 case OM_MSG_TYPE_BTC_OAM:
499 log_oam_trigger_btc_oam_cb(data, data_len);
500 break;
501 case OM_MSG_TYPE_BTH:
502 log_oam_trigger_bth_cb(data, data_len);
503 break;
504 case OM_MSG_TYPE_APP:
505 log_oam_trigger_app_cb(data, data_len);
506 break;
507 case OM_MSG_TYPE_HIFI:
508 log_oam_trigger_hifi_cb(data, data_len);
509 break;
510 case OM_MSG_REG32_COMMAND:
511 log_oam_trigger_reg32_cb(data, data_len);
512 break;
513 case OM_MSG_SSIBLOCK_COMMAND:
514 log_oam_trigger_ssi_block_cb(data, data_len);
515 break;
516 default:
517 break;
518 }
519 }
520
log_oam_prase_message(void)521 void log_oam_prase_message(void)
522 {
523 #ifndef HSO_SUPPORT
524 uint8_t loop, prime_id;
525 uint8_t *data = NULL;
526 uint16_t data_len;
527 om_msg_header_stru_t *pst_oml_header = NULL;
528
529 for (loop = 0; loop < LOG_OAM_RX_BUFF_NUM; loop++) {
530 /* If this buff is not a complete message */
531 if (g_log_oam_rx_buffer[loop].uc_buff_state != OML_BUFF_USED) { continue; }
532
533 pst_oml_header = (om_msg_header_stru_t *)(g_log_oam_rx_buffer[loop].auc_buff);
534 data = (uint8_t *)pst_oml_header;
535 data_len = pst_oml_header->frame_len;
536 prime_id = (pst_oml_header->prime_id & LOG_OML_HEADER_PRIME_ID_MASK);
537 log_oam_trigger(pst_oml_header, prime_id, data, data_len);
538 #ifndef USE_GPIO_SIMULATE_SSI
539 oml_pf_log_print2(LOG_BCORE_PLT_LIB_LOG, LOG_NUM_LIB_LOG, LOG_LEVEL_INFO, \
540 "[OML]recv oml msg type:%d, length:%d", pst_oml_header->func_type, data_len);
541 #endif
542
543 /* Clean state and buffer */
544 g_log_oam_rx_buffer[loop].uc_buff_state = OML_BUFF_NOT_USED;
545 g_log_oam_rx_buffer[loop].s_buff_used_len = 0;
546 }
547 #endif
548 }
549
oml_msg_parse(uint8_t * data,uint16_t data_len)550 void oml_msg_parse(uint8_t *data, uint16_t data_len)
551 {
552 om_msg_header_stru_t *pst_oml_header = (om_msg_header_stru_t *)(data);
553 log_oam_trigger(pst_oml_header, 0, data, data_len);
554 }
555
556 #if (defined CONFIG_DFX_SUPPORT_CUSTOM_LOG) && (CONFIG_DFX_SUPPORT_CUSTOM_LOG == DFX_YES)
557 #elif (CORE_NUMS > 1) && !defined(IPC_NEW)
get_hci_data_action_handler(ipc_action_t message,const volatile ipc_payload * payload_p,cores_t src,uint32_t id)558 bool get_hci_data_action_handler(ipc_action_t message,
559 const volatile ipc_payload *payload_p, cores_t src, uint32_t id)
560 {
561 if (message != IPC_ACTION_HCI_INFORM) {
562 PRINT("receive hci message fail!\r\n");
563 return true;
564 }
565
566 UNUSED(message);
567 UNUSED(src);
568 UNUSED(id);
569 #ifndef DEBUG_FUNC_UNSUPPORT
570 oml_pf_log_print0(LOG_BCORE_PLT_LIB_LOG, LOG_NUM_LIB_LOG, LOG_LEVEL_INFO, "receive hci message succ!");
571 if (g_log_oml_btc_oam_callback != NULL) {
572 oml_pf_log_print1(LOG_BCORE_PLT_LIB_LOG, LOG_NUM_LIB_LOG, LOG_LEVEL_INFO,
573 "[OML]recv hci msg length:%d", payload_p->hci_data_type.length);
574 g_log_oml_btc_oam_callback((uint8_t*)payload_p->hci_data_type.data, payload_p->hci_data_type.length);
575 }
576 #else
577 UNUSED(payload_p);
578 PRINT("receive hci message succ!\r\n");
579 #endif
580 return true;
581 }
582 #endif
583
584 #elif (defined CONFIG_DFX_SUPPORT_CUSTOM_LOG) && (CONFIG_DFX_SUPPORT_CUSTOM_LOG == DFX_YES)
585 #else /* SYS_DEBUG_MODE_ENABLE == NO */
586 // This branch should be deleted after the code of BTC has been finished.
587 #ifdef SUPPORT_IPC
588 #include "log_oam_msg.h"
589 #include "ipc_actions.h"
590
591 /* Send the result of start hooking to app core */
send_bt_ap_hook_data(ipc_bt_ap_hook_type_e hook_type,uint32_t addr,uint32_t len,uint32_t value)592 void send_bt_ap_hook_data(ipc_bt_ap_hook_type_e hook_type, uint32_t addr, uint32_t len, uint32_t value)
593 {
594 UNUSED(hook_type);
595 UNUSED(addr);
596 UNUSED(len);
597 UNUSED(value);
598 }
599
log_oam_register_handler_callback(uint8_t message_type,oam_cmd_handle_callback callback)600 bool log_oam_register_handler_callback(uint8_t message_type, oam_cmd_handle_callback callback)
601 {
602 UNUSED(message_type);
603 UNUSED(callback);
604
605 return true;
606 }
607
get_hci_data_action_handler(ipc_action_t message,const volatile ipc_payload * payload_p,cores_t src,uint32_t id)608 bool get_hci_data_action_handler(ipc_action_t message,
609 const volatile ipc_payload *payload_p, cores_t src, uint32_t id)
610 {
611 UNUSED(message);
612 UNUSED(payload_p);
613 UNUSED(src);
614 UNUSED(id);
615 return true;
616 }
617 #endif
618 #endif /* end of SYS_DEBUG_MODE_ENABLE == NO */
619