/*************************************************************************** * * Copyright 2015-2019 BES. * All rights reserved. All unpublished rights reserved. * * No part of this work may be used or reproduced in any form or by any * means, or stored in a database or retrieval system, without prior written * permission of BES. * * Use of this work is governed by a license granted by BES. * This work contains confidential and proprietary information of * BES. which is protected by copyright, trade secret, * trademark and other intellectual property rights. * ****************************************************************************/ #if defined(_AUTO_TEST_) #include "cmsis_os.h" #include "pmu.h" #include "hal_trace.h" #include "hal_aud.h" #include "hal_key.h" #include "apps.h" #include "app_thread.h" #include "app_status_ind.h" #include "nvrecord.h" #include "hal_timer.h" #include "hal_chipid.h" extern "C" { #include "besbt_cfg.h" #ifndef ENHANCED_STACK #include "eventmgr.h" #include "me.h" #include "sec.h" #include "avrcpi.h" #include "sys/mei.h" #endif #include "a2dp.h" #include "avdtp.h" #include "avctp.h" #include "avrcp.h" } #include "app_bt.h" #include "btapp.h" #include "hal_norflash.h" #include "norflash_api.h" #include "app_utils.h" #include "at_thread.h" #include "at_thread_user.h" #include "tgt_hardware.h" #include "app_bt_stream.h" #include "app_audio.h" #include "hal_bootmode.h" #include "bt_drv_interface.h" #include "app_battery.h" #include "hal_sleep.h" #include "app_bt_stream.h" #include "app_hfp.h" #include "app_a2dp.h" // ------------------------------------------------- // auto test command list. // AUTO_TEST AT_TEST Auto test ok. // BT_INIT AT_INIT BT Init ok. // POWER_ON POWER_ON Power on. // POWER_OFF SYS_POWER_OFF System shutdown. // REBOOT SYS_RESET System reset. // Power on. // PMU_SHUTDOWN PMU_SHUTDOWN Pmu shutdown. // Power on. // CONNECT CONNECT Connect ok. // Page timeout // PAIRING PAIRING Paring ok. // CONNECT_TWS CONNECT_TWS Connect tws ok. // CALL_SETUP CALL_SETUP:112 Call setup ok. // CALL_HANGUP CALL_HANGUP Call hangup ok. // MUSIC_ON MUSIC_ON Music on ok. // MUSIC_SUSPEND MUSIC_SUSPEND Music suspend ok. // SLEEP SLEEP_CHECK Sleep ok. // SLEEP_CLEAN SLEEP_CLEAN Sleep clean ok. // WAKEUP WAKEUP Wakeup ok. // STANDBY STANDBY // SWITCH_FREQ SWITCH_FREQ Switch freq ok. // SIMULATE_KEY SIMULATE_KEY=, Simulate key ok. // NORFALSH NORFLASH Norflash ok. // NORFALSH_SUSPEND NORFLASH_SUSPEND Norflash suspend ok. // MEMORY MEMORY Memory ok. //--------------------------------------------------------- typedef enum { AT_CMD_ID_TEST , AT_CMD_ID_POWER_OFF , AT_CMD_ID_REBOOT , AT_CMD_ID_PMU_SHUTDOWN, AT_CMD_ID_CONNECT , AT_CMD_ID_DISCONNECT , AT_CMD_ID_PAIRING , AT_CMD_ID_CONNECT_TWS , AT_CMD_ID_CALL_SETUP , AT_CMD_ID_CALL_HANGUP , AT_CMD_ID_MUSIC_ON , AT_CMD_ID_MUSIC_SUSPEND, AT_CMD_ID_SLEEP , AT_CMD_ID_SLEEP_CLEAN , AT_CMD_ID_WAKEUP , AT_CMD_ID_SWITCH_FREQ , AT_CMD_ID_POWER_ON , AT_CMD_ID_BT_INIT , AT_CMD_ID_SIMULATE_KEY , AT_CMD_ID_NORFLASH, AT_CMD_ID_NORFLASH_SUSPEND, AT_CMD_ID_MEMORY, AT_CMD_ID_GET_MAC, AT_CMD_ID_GET_NAME, AT_CMD_ID_SET_LOOPBACK, AT_CMD_ID_SET_LED, AT_CMD_ID_ENTER_SIGNAL, AT_CMD_ID_ENTER_NO_SIGNAL, AT_CMD_ID_NO_SIGNAL_BLE, AT_CMD_ID_NO_SIGNAL_BT, AT_CMD_ID_GET_BATTERY, AT_CMD_ID_SET_VOLUME, AT_CMD_ID_GET_FWVER, AT_CMD_ID_GET_BOOTMODE, AT_CMD_ID_COUNT, }AT_CMD_ID_ENUM_T; #define AT_CMD_TEST "AUTO_TEST" #define AT_CMD_POWER_OFF "POWER_OFF" #define AT_CMD_REBOOT "SYS_RESET" #define AT_CMD_PMU_SHUTDOWN "PMU_SHUTDOWN" #define AT_CMD_CONNECT "CONNECT" #define AT_CMD_DISCONNECT "DISCONNECT" #define AT_CMD_PAIRING "PAIRING" #define AT_CMD_CONNECT_TWS "CONNECT_TWS" #define AT_CMD_CALL_SETUP "CALL_SETUP" #define AT_CMD_CALL_HANGUP "CALL_HANGUP" #define AT_CMD_MUSIC_ON "MUSIC_ON" #define AT_CMD_MUSIC_SUSPEND "MUSIC_SUSPEND" #define AT_CMD_SLEEP "SLEEP_ENTER" #define AT_CMD_SLEEP_CLEAN "SLEEP_CLEAN" #define AT_CMD_WAKEUP "WAKEUP" #define AT_CMD_SWITCH_FREQ "SWITCH_FREQ" #define AT_CMD_POWER_ON "POWER_ON" #define AT_CMD_BT_INIT "BT_INIT" #define AT_CMD_SIMULATE_KEY "SIMULATE_KEY" #define AT_CMD_NORFLASH "NORFLASH" #define AT_CMD_NORFLASH_SUSPEND "NORFLASH_SUSPEND" #define AT_CMD_MEMORY "MEMORY" #define AT_CMD_GET_MAC "GET_MAC" #define AT_CMD_GET_NAME "GET_NAME" #define AT_CMD_SET_LOOPBACK "SET_LOOPBACK" #define AT_CMD_SET_LED "SET_LED" #define AT_CMD_ENTER_SIGNAL "ENTER_SIGNAL" #define AT_CMD_ENTER_NO_SIGNAL "ENTER_NO_SIGNAL" #define AT_CMD_NO_SIGNAL_BLE "NO_SIGNAL_BLE" #define AT_CMD_NO_SIGNAL_BT "NO_SIGNAL_BT" #define AT_CMD_GET_BATTERY "GET_BATTERY" #define AT_CMD_SET_VOLUME "SET_VOLUME" #define AT_CMD_GET_FWVER "GET_FWVER" #define AT_CMD_GET_BOOTMODE "GET_BOOTMODE" #define AT_CMD_RESP_TEST "Auto test ok." #define AT_CMD_RESP_POWER_OFF "System shutdown" #define AT_CMD_RESP_REBOOT "System reset." #define AT_CMD_RESP_PMU_SHUTDOWN "Pmu shutdown." #define AT_CMD_RESP_CONNECT "Connect ok." #define AT_CMD_RESP_DISCONNECT "Disconnect ok." #define AT_CMD_RESP_PAIRING "Pairing ok." #define AT_CMD_RESP_CONNECT_TWS "Connect tws ok." #define AT_CMD_RESP_CALL_SETUP "Call setup ok." #define AT_CMD_RESP_CALL_HANGUP "Call hangup ok." #define AT_CMD_RESP_MUSIC_ON "Music on ok." #define AT_CMD_RESP_MUSIC_SUSPEND "Music suspend ok." #define AT_CMD_RESP_SLEEP "Sleep ok." #define AT_CMD_RESP_SLEEP_CLEAN "Sleep clean ok." #define AT_CMD_RESP_WAKEUP "Wakeup ok." #define AT_CMD_RESP_SWITCH_FREQ "Switch freq ok." #define AT_CMD_RESP_POWER_ON "Power on." #define AT_CMD_RESP_BT_INIT "BT Init ok." #define AT_CMD_RESP_SIMULATE_KEY "Simulate key ok." #define AT_CMD_RESP_STANDBY "" #define AT_CMD_RESP_NORFLASH "Norflash ok." #define AT_CMD_RESP_NORFLASH_SUSPEND "Norflash suspend ok." #define AT_CMD_RESP_MEMORY "Memory ok." #define AT_CMD_RESP_LED "LED Display ok." #define AT_CMD_RESP_BATTERY "Battery ok." #define AT_CMD_RESP_LOOPBACK "LoopBack ok." #define AT_CMD_RESP_MAC "Get MAC ok." #define AT_CMD_RESP_FWVER "Get FWVER ok." #define AT_CMD_RESP_BOOTMODE "Get Bootmode ok." #define AT_CMD_RESP_TIME_OUT "Time out." #define AT_CMD_RESP_ERROR "Error." #define CMD_OUT_TIME_MS (30*1000) // millisecond. typedef void (*APP_BT_AUTO_TEST_T)(uint32_t, uint32_t); typedef enum { AT_STATUS_FREE, AT_STATUS_BUSY, }AT_STATUS_T; typedef struct { AT_CMD_ID_ENUM_T cmd_id; const char* cmd; APP_BT_AUTO_TEST_T pFunc; } AT_CMD_FRAME_T; typedef struct { AT_CMD_ID_ENUM_T cmd_id; const char* resp; uint32_t count; }AT_CMD_RESP; typedef struct { AT_CMD_ID_ENUM_T cur_cmd_id; AT_STATUS_T status; uint32_t start_time; uint32_t param; uint32_t pfunc; }AT_STAUTS; #if 1 #define AT_TRACE TRACE #else #define AT_TRACE(str,...) #endif void at_test(uint32_t param0,uint32_t param1); void at_power_off(uint32_t param0,uint32_t param1); void at_reboot(uint32_t param0,uint32_t param1); void at_pmu_shutdown(uint32_t param0,uint32_t param1); void at_connet(uint32_t param0,uint32_t param1); void at_disconnet(uint32_t param0,uint32_t param1); void at_pairing(uint32_t param0,uint32_t param1); void at_connect_tws(uint32_t param0,uint32_t param1); void at_call_setup(uint32_t param0,uint32_t param1); void at_call_hangup(uint32_t param0,uint32_t param1); void at_music_on(uint32_t param0,uint32_t param1); void at_music_suspend(uint32_t param0,uint32_t param1); void at_sleep(uint32_t param0,uint32_t param1); void at_sleep_clean(uint32_t param0,uint32_t param1); void at_wakeup(uint32_t param0,uint32_t param1); void at_switch_freq(uint32_t param0,uint32_t param1); void at_power_on(uint32_t param0,uint32_t param1); void at_bt_init(uint32_t param0,uint32_t param1); void at_simulate_key(uint32_t param0,uint32_t param1); void at_norflash(uint32_t param0,uint32_t param1); void at_norflash_suspend(uint32_t param0,uint32_t param1); void at_memory(uint32_t param0,uint32_t param1); void at_get_mac(uint32_t param0,uint32_t param1); void at_get_devicename(uint32_t param0,uint32_t param1); void at_set_loopback(uint32_t param0,uint32_t param1); void at_set_led(uint32_t param0,uint32_t param1); void at_enter_signaling_mode(uint32_t param0,uint32_t param1); void at_enter_no_signaling_mode(uint32_t param0,uint32_t param1); void at_no_signaling_ble_test(uint32_t param0,uint32_t param1); void at_no_signaling_bt_test(uint32_t param0,uint32_t param1); void at_get_battery(uint32_t param0,uint32_t param1); void at_set_volume(uint32_t param0,uint32_t param1); void at_get_fwversion(uint32_t param0,uint32_t param1); void at_get_bootmode(uint32_t param0,uint32_t param1); extern "C" int system_shutdown(void); extern int system_reset(void); extern void bt_key_send(uint32_t code, uint16_t event); extern void system_get_fwversion(uint8_t *fw_rev_0, uint8_t *fw_rev_1, uint8_t *fw_rev_2, uint8_t *fw_rev_3); #if defined(BT_USB_AUDIO_DUAL_MODE_TEST) extern "C" void test_btusb_switch(void); extern "C" void test_btusb_switch_to_bt(void); extern "C" void test_btusb_switch_to_usb(void); #endif static const AT_CMD_FRAME_T g_at_cmd_frame[] = { {AT_CMD_ID_TEST ,AT_CMD_TEST ,at_test }, {AT_CMD_ID_POWER_OFF ,AT_CMD_POWER_OFF ,at_power_off }, {AT_CMD_ID_REBOOT ,AT_CMD_REBOOT ,at_reboot }, {AT_CMD_ID_PMU_SHUTDOWN ,AT_CMD_PMU_SHUTDOWN ,at_pmu_shutdown }, {AT_CMD_ID_CONNECT ,AT_CMD_CONNECT ,at_connet }, {AT_CMD_ID_DISCONNECT ,AT_CMD_DISCONNECT ,at_disconnet }, {AT_CMD_ID_PAIRING ,AT_CMD_PAIRING ,at_pairing }, {AT_CMD_ID_CONNECT_TWS ,AT_CMD_CONNECT_TWS ,at_connect_tws }, {AT_CMD_ID_CALL_SETUP ,AT_CMD_CALL_SETUP ,at_call_setup }, {AT_CMD_ID_CALL_HANGUP ,AT_CMD_CALL_HANGUP ,at_call_hangup }, {AT_CMD_ID_MUSIC_ON ,AT_CMD_MUSIC_ON ,at_music_on }, {AT_CMD_ID_MUSIC_SUSPEND ,AT_CMD_MUSIC_SUSPEND ,at_music_suspend }, {AT_CMD_ID_SLEEP ,AT_CMD_SLEEP ,at_sleep }, {AT_CMD_ID_SLEEP_CLEAN ,AT_CMD_SLEEP_CLEAN ,at_sleep_clean }, {AT_CMD_ID_WAKEUP ,AT_CMD_WAKEUP ,at_wakeup }, {AT_CMD_ID_SWITCH_FREQ ,AT_CMD_SWITCH_FREQ ,at_switch_freq }, {AT_CMD_ID_POWER_ON ,AT_CMD_POWER_ON ,at_power_on }, {AT_CMD_ID_BT_INIT ,AT_CMD_BT_INIT ,at_bt_init }, {AT_CMD_ID_SIMULATE_KEY ,AT_CMD_SIMULATE_KEY ,at_simulate_key }, {AT_CMD_ID_NORFLASH ,AT_CMD_NORFLASH ,at_norflash }, {AT_CMD_ID_NORFLASH_SUSPEND ,AT_CMD_NORFLASH_SUSPEND ,at_norflash_suspend }, {AT_CMD_ID_MEMORY ,AT_CMD_MEMORY ,at_memory }, {AT_CMD_ID_GET_MAC ,AT_CMD_GET_MAC ,at_get_mac }, {AT_CMD_ID_GET_NAME ,AT_CMD_GET_NAME ,at_get_devicename }, {AT_CMD_ID_SET_LOOPBACK ,AT_CMD_SET_LOOPBACK ,at_set_loopback }, {AT_CMD_ID_SET_LED ,AT_CMD_SET_LED ,at_set_led }, {AT_CMD_ID_ENTER_SIGNAL ,AT_CMD_ENTER_SIGNAL ,at_enter_signaling_mode }, {AT_CMD_ID_ENTER_NO_SIGNAL ,AT_CMD_ENTER_NO_SIGNAL ,at_enter_no_signaling_mode }, {AT_CMD_ID_NO_SIGNAL_BLE ,AT_CMD_NO_SIGNAL_BLE ,at_no_signaling_ble_test }, {AT_CMD_ID_NO_SIGNAL_BT ,AT_CMD_NO_SIGNAL_BT ,at_no_signaling_bt_test }, {AT_CMD_ID_GET_BATTERY ,AT_CMD_GET_BATTERY ,at_get_battery }, {AT_CMD_ID_SET_VOLUME ,AT_CMD_SET_VOLUME ,at_set_volume }, {AT_CMD_ID_GET_FWVER ,AT_CMD_GET_FWVER ,at_get_fwversion }, {AT_CMD_ID_GET_BOOTMODE ,AT_CMD_GET_BOOTMODE ,at_get_bootmode }, {AT_CMD_ID_COUNT ,(const char*)NULL ,NULL}, }; static AT_CMD_RESP g_at_cmd_resp[] = { {AT_CMD_ID_TEST ,AT_CMD_RESP_TEST ,0 }, {AT_CMD_ID_POWER_OFF ,AT_CMD_RESP_POWER_OFF ,0 }, {AT_CMD_ID_REBOOT ,AT_CMD_RESP_REBOOT ,0 }, {AT_CMD_ID_PMU_SHUTDOWN ,AT_CMD_RESP_PMU_SHUTDOWN ,0 }, {AT_CMD_ID_CONNECT ,AT_CMD_RESP_CONNECT ,0 }, {AT_CMD_ID_DISCONNECT ,AT_CMD_RESP_DISCONNECT ,0 }, {AT_CMD_ID_PAIRING ,AT_CMD_RESP_PAIRING ,0 }, {AT_CMD_ID_CONNECT_TWS ,AT_CMD_RESP_CONNECT_TWS ,0 }, {AT_CMD_ID_CALL_SETUP ,AT_CMD_RESP_CALL_SETUP ,0 }, {AT_CMD_ID_CALL_HANGUP ,AT_CMD_RESP_CALL_HANGUP ,0 }, {AT_CMD_ID_MUSIC_ON ,AT_CMD_RESP_MUSIC_ON ,0 }, {AT_CMD_ID_MUSIC_SUSPEND ,AT_CMD_RESP_MUSIC_SUSPEND ,0 }, {AT_CMD_ID_SLEEP ,AT_CMD_RESP_SLEEP ,0 }, {AT_CMD_ID_SLEEP_CLEAN ,AT_CMD_RESP_SLEEP_CLEAN ,0 }, {AT_CMD_ID_WAKEUP ,AT_CMD_RESP_WAKEUP ,0 }, {AT_CMD_ID_SWITCH_FREQ ,AT_CMD_RESP_SWITCH_FREQ ,0 }, {AT_CMD_ID_POWER_ON ,AT_CMD_RESP_POWER_ON ,0 }, {AT_CMD_ID_BT_INIT ,AT_CMD_RESP_BT_INIT ,0 }, {AT_CMD_ID_SIMULATE_KEY ,AT_CMD_RESP_SIMULATE_KEY ,0 }, {AT_CMD_ID_NORFLASH ,AT_CMD_RESP_NORFLASH ,0 }, {AT_CMD_ID_NORFLASH_SUSPEND ,AT_CMD_RESP_NORFLASH_SUSPEND ,0 }, {AT_CMD_ID_MEMORY ,AT_CMD_RESP_MEMORY ,0 }, {AT_CMD_ID_COUNT ,(const char*)NULL ,0 }, }; AT_STAUTS g_at_status = {AT_CMD_ID_COUNT,AT_STATUS_FREE,0,0,0}; void _at_trim(uint8_t* buff) { uint8_t* p; uint32_t len; // int32_t i; len = strlen((char*)buff); p = buff + (len - 1); while(1) { if(*p == 0x20 || *p == 0x09 || *p == 0x0A || *p == 0x0D) { *p = 0; p--; } else { break; } if(p == buff) { break; } } p = buff; while(1) { if(*p == 0x20 || *p == 0x09) { p++; } else { break; } } while(*p) { *buff = *p; buff ++; p++; } } /* static int _at_strtohex(uint8_t* hex, char* str, int len) { int i = 0; char* begin; char* end; //char* tmp; char* hex_unit; begin = str; end = str; for(i = 0; i < len; i++) { hex_unit = begin; end = strstr(begin,","); if(end) { *end = 0; begin = end + 1; } else { } hex[i] = (uint8_t)strtol(hex_unit,NULL,16); } if(i == len) return 0; else return -1; } */ static char* _at_get_cmd_resp(AT_CMD_ID_ENUM_T cmd_id) { uint32_t i; uint32_t cmd_count = 0; char* resp = NULL; cmd_count = sizeof(g_at_cmd_resp)/sizeof(AT_CMD_RESP); for(i = 0; i < cmd_count; i++) { if(AT_CMD_ID_COUNT == g_at_cmd_resp[i].cmd_id) { AT_TRACE(1,"_debug: undefined at cmd resp, cmd_id = %d.",cmd_id); resp = NULL; goto _func_end; } if(cmd_id == g_at_cmd_resp[i].cmd_id) { if(g_at_cmd_resp[i].count > 0) { resp = (char*)g_at_cmd_resp[i].resp; g_at_cmd_resp[i].count = 0; AT_TRACE(2,"_debug: ount > 0,cmd_id = %d,resp = %s.",cmd_id,resp); } else { resp = NULL; } break; } } _func_end: return resp; } /* static AT_STATUS_T _at_get_status(void) { if(g_at_status.cur_cmd_id == AT_CMD_ID_COUNT) return AT_STATUS_FREE; return g_at_status.status; } */ static AT_CMD_ID_ENUM_T _at_get_cur_cmd_id(void) { return g_at_status.cur_cmd_id; } static void _at_set_status(AT_CMD_ID_ENUM_T cmd_id,AT_STATUS_T status,uint32_t param,uint32_t pfuc) { g_at_status.status = status; if(status == AT_STATUS_BUSY) { g_at_status.cur_cmd_id = cmd_id; g_at_status.start_time = hal_sys_timer_get(); } g_at_status.param = param; g_at_status.pfunc = pfuc; } static void _at_resp(void) { AT_CMD_ID_ENUM_T cur_cmd_id; uint32_t wait_time; char* resp; cur_cmd_id = _at_get_cur_cmd_id(); if(cur_cmd_id == AT_CMD_ID_COUNT) { TRACE_IMM(1,"AUTO_TEST:%s",AT_CMD_RESP_ERROR); return; } resp = _at_get_cmd_resp(cur_cmd_id); if(resp) { //osDelay(64); TRACE_IMM(1,"AUTO_TEST: %s",resp); //osDelay(64); _at_set_status(AT_CMD_ID_COUNT,AT_STATUS_FREE,0,0); } else { wait_time = TICKS_TO_MS(hal_sys_timer_get() - g_at_status.start_time); if(wait_time < CMD_OUT_TIME_MS) { //osDelay(4); //app_bt_send_request(APP_BT_REQ_AUTO_TEST, (uint32_t)g_at_status.param,cur_cmd_id, //g_at_status.pfunc); AT_TRACE(1,"_debug: _at_resp,auto_test wait : %d(ms)",wait_time); } else { _at_set_status(AT_CMD_ID_COUNT,AT_STATUS_FREE,0,0); AT_TRACE(2,"AUTO_TEST:%s,wait time = %d(ms)",AT_CMD_RESP_TIME_OUT,wait_time); } } } #define AT_PARAM_LEN 256 uint8_t at_param_buff[AT_PARAM_LEN]; extern "C" int auto_test_prase(uint8_t *cmd) { int ret = 0; uint8_t i; uint8_t* cmd_name = NULL; uint8_t* cmd_param = NULL; uint8_t* p; AT_CMD_ID_ENUM_T cmd_id; uint32_t param_len; if(NULL == cmd) { ret = -1; goto _func_end; } AT_TRACE(1,"_debug: cmd = %s",cmd); cmd_name = cmd; p = (uint8_t*)strstr((char*)cmd,(char*)"="); if(p) { *p = 0; cmd_param = (p + 1); _at_trim(cmd_param); } else { cmd_param = NULL; } _at_trim(cmd_name); for(i = 0; i < sizeof(g_at_cmd_frame)/sizeof(AT_CMD_FRAME_T); i++) { if(AT_CMD_ID_COUNT == g_at_cmd_frame[i].cmd_id) { AT_TRACE(1,"_debug: undefined at cmd: %s.",cmd); ret = -2; goto _func_end; } if(!strcmp((const char *)cmd, (const char *)g_at_cmd_frame[i].cmd)) { if(NULL == g_at_cmd_frame[i].pFunc) { ret = -3; goto _func_end; } /* if(AT_CMD_ID_REBOOT != g_at_cmd_frame[i].cmd_id) { if(_at_get_status() != AT_STATUS_FREE) { ret = -2; AT_TRACE(3,"_debug: auto_test is busy. cmd = %s,cmd_id = %d,cur_cmd_id = %d", g_at_cmd_frame[i].cmd_id,cmd,g_at_status.cur_cmd_id); goto _func_end; } } */ cmd_id = g_at_cmd_frame[i].cmd_id; // AT_TRACE(2,"_debug: %s,line= %d.",__func__,__LINE__); //memset(at_param_buff,0,sizeof(at_param_buff)); if(NULL != cmd_param) { param_len = strlen((char*)cmd_param); param_len = param_len < sizeof(at_param_buff) ? param_len : sizeof(at_param_buff) - 1; if(param_len > 0) { strncpy((char*)at_param_buff,(char*)cmd_param,param_len); } } _at_set_status(cmd_id,AT_STATUS_BUSY,(uint32_t)cmd_param,(uint32_t)g_at_cmd_frame[i].pFunc); at_enqueue_cmd((uint32_t)cmd_id,(uint32_t)at_param_buff,(uint32_t)g_at_cmd_frame[i].pFunc); //g_at_cmd_frame[i].pFunc((uint32_t)cmd_param,cmd_id); break; } } _func_end: if(ret != 0) { AT_TRACE(1,"_debug: parse failed,ret = %d.",ret); } return ret; } extern "C" int auto_test_send(char *resp) { uint32_t i; uint32_t cmd_count = 0; int32_t ret = 0; cmd_count = sizeof(g_at_cmd_resp)/sizeof(AT_CMD_RESP); // AT_TRACE(1,"_debug: auto_test_send : %s",resp); for(i = 0; i < cmd_count; i++) { if(AT_CMD_ID_COUNT == g_at_cmd_resp[i].cmd_id) { AT_TRACE(1,"_debug: auto_test_send: undefined at cmd resp, resp = %s.",resp); ret = -1; goto _func_end; } if(!strncmp((const char *)resp, (const char *)g_at_cmd_resp[i].resp,strlen((char*)g_at_cmd_resp[i].resp))) { if( g_at_cmd_resp[i].cmd_id == AT_CMD_ID_POWER_ON || // g_at_cmd_resp[i].cmd_id == AT_CMD_ID_POWER_OFF || // g_at_cmd_resp[i].cmd_id == AT_CMD_ID_REBOOT || g_at_cmd_resp[i].cmd_id == g_at_status.cur_cmd_id) { TRACE_IMM(1,"AUTO_TEST:%s",resp); _at_set_status(AT_CMD_ID_COUNT,AT_STATUS_FREE,0,0); } else { g_at_cmd_resp[i].count = 1; AT_TRACE(2,"_debug: auto_test_send: set count to 1, i = %d, resp = %s.",i,resp); } break; } } _func_end: if(ret != 0) { AT_TRACE(1,"_debug: auto_test_send: %s undefine !!!!!",resp); } return ret; } void at_test(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am app_auto_test"); AUTO_TEST_SEND(AT_CMD_RESP_TEST); } void at_power_off(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; AT_TRACE(0,"_debug: I am at_power_off"); pmu_at_skip_shutdown(false); system_shutdown(); } void at_reboot(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; AT_TRACE(0,"_debug: I am at_reboot"); //system_reset(); app_reset(); } void at_pmu_shutdown(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am at_reboot"); //system_reset(); AUTO_TEST_SEND(AT_CMD_RESP_PMU_SHUTDOWN); // pmu_rtc_enable(); // pmu_rtc_set(5); // pmu_rtc_set_alarm(10); pmu_at_skip_shutdown(true); pmu_shutdown(); } void at_connet(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am at_connet"); //app_tws_charger_box_opened(); _at_resp(); } void at_disconnet(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am at_disconnet"); _at_resp(); } void at_pairing(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am at_pairing"); _at_resp(); } void at_connect_tws(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am at_connect_tws"); _at_resp(); } void at_call_setup(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am at_call_setup"); _at_resp(); } void at_call_hangup(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am at_call_hangup"); _at_resp(); } static void music_on_callback(void); #define MUSIC_ON_DELAY_MS 500 osTimerDef(MUSIC_ON_TIMER, (void (*)(void const *))music_on_callback); static osTimerId music_on_timer = NULL; static bool music_on_flag = 1; static void music_on_callback(void) { app_voice_report(APP_STATUS_INDICATION_WARNING, 0); } void at_music_on(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; AT_TRACE(0,"_debug: I am at_music_on"); app_voice_report(APP_STATUS_INDICATION_WARNING, 0); if(music_on_flag) { music_on_timer = osTimerCreate (osTimer(MUSIC_ON_TIMER), osTimerPeriodic, 0); music_on_flag = 0; } osTimerStart(music_on_timer, MUSIC_ON_DELAY_MS); _at_resp(); } void at_music_suspend(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; AT_TRACE(0,"_debug: I am at_music_suspend"); osTimerStop(music_on_timer); _at_resp(); } void at_sleep(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; AT_TRACE(0,"_debug: I am at_sleep"); //hal_sleep_enter_sleep(); //app_bt_stop_sniff(); _at_resp(); } void at_sleep_clean(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; unsigned int i; //AT_TRACE(0,"_debug: I am at_sleep_clean"); for(i = 0; i < sizeof(g_at_cmd_resp)/sizeof(AT_CMD_RESP); i++) { if(AT_CMD_ID_SLEEP_CLEAN == g_at_cmd_resp[i].cmd_id) { g_at_cmd_resp[i].count = 0; break; } } AUTO_TEST_SEND(AT_CMD_RESP_SLEEP_CLEAN); } void at_wakeup(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am at_wakeup"); _at_resp(); } void at_switch_freq(uint32_t param0,uint32_t param1) { char* p = (char*)param0; char* user_str; char* freq_str; uint32_t user = 0xffffffff; uint32_t freq = 0xffffffff; int i; AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am at_switch_freq"); user_str = (char*)param0; p = strstr(user_str,","); if(p) { *p = 0; p ++; } else { AT_TRACE(0,"_debug: at_switch_freq: param error 0."); goto _func_end; } _at_trim((uint8_t*)user_str); if(*user_str) { user = atoi(user_str); } else { AT_TRACE(0,"_debug: at_switch_freq: param error 1."); goto _func_end; } freq_str = p; _at_trim((uint8_t*)freq_str); if(*freq_str) { freq = atoi(freq_str); } else { AT_TRACE(0,"_debug: at_switch_freq: param error 2."); goto _func_end; } if(user >= APP_SYSFREQ_USER_QTY || freq >= APP_SYSFREQ_FREQ_QTY) { AT_TRACE(0,"_debug: at_switch_freq: param error 3."); goto _func_end; } //AT_TRACE(2,"_debug: at_switch_freq: user = %d, freq = %d.",user,freq); app_sysfreq_req((APP_SYSFREQ_USER_T)user,(APP_SYSFREQ_FREQ_T)freq); for(i = 0; i < 10000; i ++) { } AUTO_TEST_SEND("Switch freq ok."); _func_end: return; } void at_power_on(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am at_power_on"); AUTO_TEST_SEND(AT_CMD_RESP_POWER_ON); } void at_bt_init(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; //AT_TRACE(0,"_debug: I am at_bt_init"); _at_resp(); } #include "app_key.h" typedef struct { uint32_t key; const char* key_str; }AT_KEY_MAP; AT_KEY_MAP key_code_map[] = { {(uint32_t)HAL_KEY_CODE_NONE,"KEY_CODE_NONE"}, {(uint32_t)HAL_KEY_CODE_PWR ,"KEY_CODE_PWR" }, {(uint32_t)HAL_KEY_CODE_FN1 ,"KEY_CODE_FN1" }, {(uint32_t)HAL_KEY_CODE_FN2 ,"KEY_CODE_FN2" }, {(uint32_t)HAL_KEY_CODE_FN3 ,"KEY_CODE_FN3" }, {(uint32_t)HAL_KEY_CODE_FN4 ,"KEY_CODE_FN4" }, {(uint32_t)HAL_KEY_CODE_FN5 ,"KEY_CODE_FN5" }, {(uint32_t)HAL_KEY_CODE_FN6 ,"KEY_CODE_FN6" }, {(uint32_t)HAL_KEY_CODE_FN7 ,"KEY_CODE_FN7" }, {(uint32_t)HAL_KEY_CODE_FN8 ,"KEY_CODE_FN8" }, {(uint32_t)HAL_KEY_CODE_FN9 ,"KEY_CODE_FN9" }, {(uint32_t)HAL_KEY_CODE_FN10,"KEY_CODE_FN10"}, {(uint32_t)HAL_KEY_CODE_FN11,"KEY_CODE_FN11"}, {(uint32_t)HAL_KEY_CODE_FN12,"KEY_CODE_FN12"}, {(uint32_t)HAL_KEY_CODE_FN13,"KEY_CODE_FN13"}, {(uint32_t)HAL_KEY_CODE_FN14,"KEY_CODE_FN14"}, {(uint32_t)HAL_KEY_CODE_FN15,"KEY_CODE_FN15"} }; AT_KEY_MAP key_event_map[] = { {(uint32_t)HAL_KEY_EVENT_NONE ,"KEY_EVENT_NONE" }, {(uint32_t)HAL_KEY_EVENT_DOWN ,"KEY_EVENT_DOWN" }, {(uint32_t)HAL_KEY_EVENT_FIRST_DOWN ,"KEY_EVENT_FIRST_DOWN" }, {(uint32_t)HAL_KEY_EVENT_CONTINUED_DOWN ,"KEY_EVENT_CONTINUED_DOWN" }, {(uint32_t)HAL_KEY_EVENT_UP ,"KEY_EVENT_UP" }, {(uint32_t)HAL_KEY_EVENT_LONGPRESS ,"KEY_EVENT_LONGPRESS" }, {(uint32_t)HAL_KEY_EVENT_LONGLONGPRESS ,"KEY_EVENT_LONGLONGPRESS" }, {(uint32_t)HAL_KEY_EVENT_CLICK ,"KEY_EVENT_CLICK" }, {(uint32_t)HAL_KEY_EVENT_DOUBLECLICK ,"KEY_EVENT_DOUBLECLICK" }, {(uint32_t)HAL_KEY_EVENT_TRIPLECLICK ,"KEY_EVENT_TRIPLECLICK" }, {(uint32_t)HAL_KEY_EVENT_ULTRACLICK ,"KEY_EVENT_ULTRACLICK" }, {(uint32_t)HAL_KEY_EVENT_RAMPAGECLICK ,"KEY_EVENT_RAMPAGECLICK" }, {(uint32_t)HAL_KEY_EVENT_REPEAT ,"KEY_EVENT_REPEAT" }, {(uint32_t)HAL_KEY_EVENT_GROUPKEY_DOWN ,"KEY_EVENT_GROUPKEY_DOWN" }, {(uint32_t)HAL_KEY_EVENT_GROUPKEY_REPEAT ,"KEY_EVENT_GROUPKEY_REPEAT" }, {(uint32_t)HAL_KEY_EVENT_INITDOWN ,"KEY_EVENT_INITDOWN" }, {(uint32_t)HAL_KEY_EVENT_INITUP ,"KEY_EVENT_INITUP" }, {(uint32_t)HAL_KEY_EVENT_INITLONGPRESS ,"KEY_EVENT_INITLONGPRESS" }, {(uint32_t)HAL_KEY_EVENT_INITLONGLONGPRESS,"KEY_EVENT_INITLONGLONGPRESS"}, {(uint32_t)HAL_KEY_EVENT_INITFINISHED ,"KEY_EVENT_INITFINISHED" } }; void at_simulate_key(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; char* code_str; char* event_str; uint32_t key_code = 0; uint16_t key_event = 0; char* p; uint32_t i; cmd_id = cmd_id; AT_TRACE(0,"_debug: I am at_simulate_key"); p = (char*)param0; code_str = p; p = strstr(p,","); if(p) { *p = 0; p++; } else { goto _func_end; } event_str = p; _at_trim((uint8_t*)code_str); _at_trim((uint8_t*)event_str); AT_TRACE(2,"_debug: code_str = %s, event_str = %s.",code_str,event_str); for(i = 0; i < sizeof(key_code_map)/sizeof(AT_KEY_MAP); i ++) { if(strncmp(code_str,key_code_map[i].key_str,strlen(code_str)) == 0) { key_code = key_code_map[i].key; break; } } if(i == sizeof(key_code_map)/sizeof(AT_KEY_MAP)) { goto _func_end; } for(i = 0; i < sizeof(key_event_map)/sizeof(AT_KEY_MAP); i ++) { if(strncmp(event_str,key_event_map[i].key_str,strlen(event_str)) == 0) { key_event = (key_event_map[i].key & 0xffff); break; } } if(i == sizeof(key_event_map)/sizeof(AT_KEY_MAP)) { goto _func_end; } AT_TRACE(2,"_debug: key_code = %d, key_event = %d.",key_code,key_event); if(key_code == HAL_KEY_CODE_FN15 && key_event == HAL_KEY_EVENT_CLICK) { #if defined(BT_USB_AUDIO_DUAL_MODE_TEST) test_btusb_switch_to_bt(); //osDelay(5000); #endif } if(key_code == HAL_KEY_CODE_FN14 && key_event == HAL_KEY_EVENT_CLICK) { #if defined(BT_USB_AUDIO_DUAL_MODE_TEST) test_btusb_switch_to_usb(); #endif } AUTO_TEST_SEND(AT_CMD_RESP_SIMULATE_KEY); //simul_key_event_process((uint32_t)key_code,(uint16_t)key_event); _func_end: return; } enum AT_FLASH_REGION_ID { FLASH_REGION_ID_CODE, FLASH_REGION_ID_FREE, FLASH_REGION_ID_CRASH_DUMP, FLASH_REGION_ID_AUD, FLASH_REGION_ID_USERDATA, FLASH_REGION_ID_FACTORY, FLASH_REGION_ID_NUMBER, }; typedef struct _flash_region_info { enum AT_FLASH_REGION_ID id; uint32_t start_addr; uint32_t end_addr; }AT_FLASH_REGION_INFO; #define AT_ALIGN(x,a) (uint32_t)(((x + a - 1)/a) * a) extern uint32_t __flash_start; extern uint32_t __flash_end; extern uint32_t __crash_dump_start; extern uint32_t __crash_dump_end; extern uint32_t __custom_parameter_start; extern uint32_t __custom_parameter_end; extern uint32_t __aud_start; extern uint32_t __aud_end; extern uint32_t __userdata_start; extern uint32_t __userdata_end; extern uint32_t __factory_start; extern uint32_t __factory_end; extern uint32_t __free_flash; #define AT_FLASH_SECTOR_SIZE 0x1000 #define AT_FLASH_BLOCK_SIZE 0x10000 AT_FLASH_REGION_INFO region_info[] = { {FLASH_REGION_ID_CODE, FLASH_C_TO_NC(AT_ALIGN((uint32_t)(&__flash_start),AT_FLASH_SECTOR_SIZE)), FLASH_C_TO_NC(AT_ALIGN((uint32_t)(&__flash_end),AT_FLASH_SECTOR_SIZE))}, {FLASH_REGION_ID_FREE, FLASH_C_TO_NC(AT_ALIGN((uint32_t)(&__flash_end + AT_FLASH_SECTOR_SIZE),AT_FLASH_SECTOR_SIZE)), FLASH_C_TO_NC(AT_ALIGN((uint32_t)(&__flash_end + AT_FLASH_SECTOR_SIZE + 16*AT_FLASH_SECTOR_SIZE),AT_FLASH_SECTOR_SIZE))},//AT_ALIGN((uint32_t)(&__crash_dump_start),AT_FLASH_SECTOR_SIZE)}, {FLASH_REGION_ID_CRASH_DUMP, FLASH_C_TO_NC(AT_ALIGN((uint32_t)(&__flash_end + AT_FLASH_SECTOR_SIZE + 16*AT_FLASH_SECTOR_SIZE),AT_FLASH_SECTOR_SIZE)),//AT_ALIGN((uint32_t)(&__crash_dump_start),AT_FLASH_SECTOR_SIZE), FLASH_C_TO_NC(AT_ALIGN((uint32_t)(&__flash_end + AT_FLASH_SECTOR_SIZE + 32*AT_FLASH_SECTOR_SIZE),AT_FLASH_SECTOR_SIZE))},//AT_ALIGN((uint32_t)(&__crash_dump_end),AT_FLASH_SECTOR_SIZE)}, {FLASH_REGION_ID_AUD, AT_ALIGN((uint32_t)(&__aud_start),AT_FLASH_SECTOR_SIZE), AT_ALIGN((uint32_t)(&__aud_end),AT_FLASH_SECTOR_SIZE)}, {FLASH_REGION_ID_USERDATA, AT_ALIGN((uint32_t)(&__userdata_start),AT_FLASH_SECTOR_SIZE), AT_ALIGN((uint32_t)(&__userdata_end),AT_FLASH_SECTOR_SIZE)}, {FLASH_REGION_ID_FACTORY, AT_ALIGN((uint32_t)(&__factory_start) + 20*AT_FLASH_SECTOR_SIZE,AT_FLASH_SECTOR_SIZE),//AT_ALIGN((uint32_t)(&__factory_start),AT_FLASH_SECTOR_SIZE), AT_ALIGN((uint32_t)(&__flash_end) + 30*AT_FLASH_SECTOR_SIZE,AT_FLASH_SECTOR_SIZE)},//AT_ALIGN((uint32_t)(&__factory_end),AT_FLASH_SECTOR_SIZE)}, }; uint8_t at_buff_r[AT_FLASH_SECTOR_SIZE]; uint8_t at_buff_r1[AT_FLASH_SECTOR_SIZE]; uint8_t at_buff_w[AT_FLASH_SECTOR_SIZE]; uint8_t at_buff_b[AT_FLASH_SECTOR_SIZE]; int32_t _at_norflash_test(uint32_t addr,uint32_t size,uint8_t is_restore) { uint32_t start_addr; uint32_t i,j; uint8_t value = 0; int32_t ret = 0; enum HAL_NORFLASH_RET_T result = HAL_NORFLASH_OK; for(i = 0; i < size/AT_FLASH_SECTOR_SIZE; i++) { // erase checking. start_addr = addr + i * AT_FLASH_SECTOR_SIZE; if(is_restore != 0) { result = hal_norflash_read(HAL_NORFLASH_ID_0,start_addr,at_buff_b,AT_FLASH_SECTOR_SIZE); if(result != HAL_NORFLASH_OK) { ret = -2; goto _func_end; } } result = hal_norflash_erase(HAL_NORFLASH_ID_0,start_addr,AT_FLASH_SECTOR_SIZE); if(result != HAL_NORFLASH_OK) { ret = -1; goto _func_end; } result = hal_norflash_read(HAL_NORFLASH_ID_0,start_addr,at_buff_r,AT_FLASH_SECTOR_SIZE); if(result != HAL_NORFLASH_OK) { ret = -2; goto _func_end; } for(j = 0; j < AT_FLASH_SECTOR_SIZE; j++) { if(at_buff_r[j] != 0xff) { ret = -3; goto _func_end; } } // write/read checking for(j = 0; j < AT_FLASH_SECTOR_SIZE; j++) { at_buff_w[j] = value ++; } result = hal_norflash_write(HAL_NORFLASH_ID_0,start_addr,at_buff_w,AT_FLASH_SECTOR_SIZE); if(result != HAL_NORFLASH_OK) { ret = -4; goto _func_end; } result = hal_norflash_read(HAL_NORFLASH_ID_0,start_addr,at_buff_r,AT_FLASH_SECTOR_SIZE); if(result != HAL_NORFLASH_OK) { ret = -5; goto _func_end; } for(j = 0; j < AT_FLASH_SECTOR_SIZE; j++) { if(at_buff_r[j] != at_buff_w[j]) { ret = -6; goto _func_end; } } if(is_restore != 0) { result = hal_norflash_erase(HAL_NORFLASH_ID_0,start_addr,AT_FLASH_SECTOR_SIZE); if(result != HAL_NORFLASH_OK) { ret = -7; break; } result = hal_norflash_write(HAL_NORFLASH_ID_0,start_addr,at_buff_b,AT_FLASH_SECTOR_SIZE); if(result != HAL_NORFLASH_OK) { ret = -8; break; } result = hal_norflash_read(HAL_NORFLASH_ID_0,start_addr,at_buff_r,AT_FLASH_SECTOR_SIZE); if(result != HAL_NORFLASH_OK) { ret = -9; goto _func_end; } for(j = 0; j < AT_FLASH_SECTOR_SIZE; j++) { if(at_buff_r[j] != at_buff_b[j]) { ret = -10; goto _func_end; } } } } _func_end: //AT_TRACE(1,"_debug: flash checking end. ret = %d.",ret); return ret; } AT_FLASH_REGION_INFO* _at_norflash_get_region_info(enum AT_FLASH_REGION_ID id) { uint32_t i; for(i = 0; i < sizeof(region_info)/sizeof(AT_FLASH_REGION_INFO); i++) { if(region_info[i].id == id) { return ®ion_info[i]; } } return NULL; } void at_norflash(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; // uint32_t start_addr = 0; // uint32_t end_addr = 0; // uint32_t size = 0; //uint8_t check_code = 1; //uint8_t check_free = 1; //uint8_t check_crash_dump = 1; //uint8_t check_aud = 1; //uint8_t check_userdata = 1; //uint8_t check_factory = 1; AT_FLASH_REGION_INFO* region_info; int32_t result = 0; uint8_t error_code = 0; cmd_id = cmd_id; uint32_t lock_pri; int idex; char *p; p = (char*)param0; idex = atoi(p); error_code = error_code; AT_TRACE(0,"_debug:at_norflash begin."); switch(idex) { case 1: { AT_TRACE(0,"_debug:at_norflash check code region."); region_info = _at_norflash_get_region_info(FLASH_REGION_ID_CODE); AT_TRACE(4,"%s: region_info, id = %d,start = 0x%x,end = 0x%x.", __func__,region_info->id,region_info->start_addr,region_info->end_addr); lock_pri = int_lock(); result = _at_norflash_test(region_info->start_addr, (region_info->end_addr - region_info->start_addr), 1); int_unlock(lock_pri); if(result != 0) { error_code = 1; goto _func_fail; } break; } case 2: { AT_TRACE(0,"_debug:at_norflash check free region."); region_info = _at_norflash_get_region_info(FLASH_REGION_ID_FREE); AT_TRACE(4,"%s: region_info, id = %d,start = 0x%x,end = 0x%x.", __func__,region_info->id,region_info->start_addr,region_info->end_addr); lock_pri = int_lock(); result = _at_norflash_test(region_info->start_addr, (region_info->end_addr - region_info->start_addr), 0); int_unlock(lock_pri); if(result != 0) { error_code = 2; goto _func_fail; } break; } case 3: { AT_TRACE(0,"_debug:at_norflash check crash_dump region."); region_info = _at_norflash_get_region_info(FLASH_REGION_ID_CRASH_DUMP); AT_TRACE(4,"%s: region_info, id = %d,start = 0x%x,end = 0x%x.", __func__,region_info->id,region_info->start_addr,region_info->end_addr); lock_pri = int_lock(); result = _at_norflash_test(region_info->start_addr, (region_info->end_addr - region_info->start_addr), 1); int_unlock(lock_pri); if(result != 0) { error_code = 3; goto _func_fail; } break; } case 4: { AT_TRACE(0,"_debug:at_norflash check aud region."); region_info = _at_norflash_get_region_info(FLASH_REGION_ID_AUD); AT_TRACE(4,"%s: region_info, id = %d,start = 0x%x,end = 0x%x.", __func__,region_info->id,region_info->start_addr,region_info->end_addr); lock_pri = int_lock(); result = _at_norflash_test(region_info->start_addr, (region_info->end_addr - region_info->start_addr), 1); int_unlock(lock_pri); if(result != 0) { error_code = 4; goto _func_fail; } break; } case 5: { AT_TRACE(0,"_debug:at_norflash check userdata region."); region_info = _at_norflash_get_region_info(FLASH_REGION_ID_USERDATA); AT_TRACE(4,"%s: region_info, id = %d,start = 0x%x,end = 0x%x.", __func__,region_info->id,region_info->start_addr,region_info->end_addr); lock_pri = int_lock(); result = _at_norflash_test(region_info->start_addr, (region_info->end_addr - region_info->start_addr), 1); int_unlock(lock_pri); if(result != 0) { error_code = 5; goto _func_fail; } break; } case 6: { AT_TRACE(0,"_debug:at_norflash check factory region."); region_info = _at_norflash_get_region_info(FLASH_REGION_ID_FACTORY); AT_TRACE(4,"%s: region_info, id = %d,start = 0x%x,end = 0x%x.", __func__,region_info->id,region_info->start_addr,region_info->end_addr); lock_pri = int_lock(); result = _at_norflash_test(region_info->start_addr, (region_info->end_addr - region_info->start_addr), 1); int_unlock(lock_pri); if(result != 0) { error_code = 6; goto _func_fail; } break; } default: AT_TRACE(0,"_debug:at_norflash idex default."); break; } //AT_TRACE(0,"_debug: I am at_norflash"); error_code = 0; AUTO_TEST_SEND(AT_CMD_RESP_NORFLASH); _func_fail: AT_TRACE(1,"_debug:Flash testing fail.error_code = %d.",error_code); } #if 0 extern "C" int32_t at_norflash_life_test(uint32_t count) { uint8_t check_free = 1; uint8_t check_crash_dump = 0; uint8_t check_aud = 0; uint8_t check_userdata = 0; uint8_t check_factory = 0; AT_FLASH_REGION_INFO* region_info; int32_t result = 0; uint8_t error_code = 0; uint32_t lock_pri; uint32_t i; static bool is_first = true; error_code = error_code; //AT_TRACE(0,"at_norflash_life_test begin."); for(i = 0; i < count; i++) { if(check_free) { region_info = _at_norflash_get_region_info(FLASH_REGION_ID_FREE); if(is_first) { TRACE(0,"free region"); TRACE(4,"%s: region_info, id = %d,start_addr = 0x%x,end_addr = 0x%x.", __func__,region_info->id,region_info->start_addr,region_info->end_addr); is_first = false; } lock_pri = int_lock(); result = _at_norflash_test(region_info->start_addr, (region_info->end_addr - region_info->start_addr), 0); int_unlock(lock_pri); if(result != 0) { error_code = 2; goto _func_fail; } } if(check_crash_dump) { TRACE(0,"at_norflash_life_test check crash_dump region."); region_info = _at_norflash_get_region_info(FLASH_REGION_ID_CRASH_DUMP); lock_pri = int_lock(); result = _at_norflash_test(region_info->start_addr, (region_info->end_addr - region_info->start_addr), 1); int_unlock(lock_pri); if(result != 0) { error_code = 3; goto _func_fail; } } if(check_aud) { TRACE(0,"at_norflash_life_test check aud region."); region_info = _at_norflash_get_region_info(FLASH_REGION_ID_AUD); lock_pri = int_lock(); result = _at_norflash_test(region_info->start_addr, (region_info->end_addr - region_info->start_addr), 1); int_unlock(lock_pri); if(result != 0) { error_code = 4; goto _func_fail; } } if(check_userdata) { TRACE(0,"at_norflash_life_test check userdata region."); region_info = _at_norflash_get_region_info(FLASH_REGION_ID_USERDATA); lock_pri = int_lock(); result = _at_norflash_test(region_info->start_addr, (region_info->end_addr - region_info->start_addr), 1); int_unlock(lock_pri); if(result != 0) { error_code = 5; goto _func_fail; } } if(check_factory) { TRACE(0,"at_norflash_life_test check factory region."); region_info = _at_norflash_get_region_info(FLASH_REGION_ID_FACTORY); lock_pri = int_lock(); result = _at_norflash_test(region_info->start_addr, (region_info->end_addr - region_info->start_addr), 1); int_unlock(lock_pri); if(result != 0) { error_code = 6; goto _func_fail; } } } error_code = 0; //TRACE(1,"at_norflash_life_test testing success. erase_count = write_count = %d.",count); return 0; _func_fail: TRACE(1,"at_norflash_life_test testing fail.error_code = %d.",error_code); return 1; } void norflash_life_test(void) { uint32_t i; uint32_t step_count; int32_t ret; step_count = 10; TRACE(1,"%s: begin.",__func__); for(i = 0; i < E_W_COUNT/step_count; i++) { ret = at_norflash_life_test(step_count); if(ret == 0) { TRACE(2,"%s: e_w ok! e_w_count = %d.",__func__,(i + 1)*step_count); } else { TRACE(2,"%s: failed! e_w_count = %d.",__func__,(i + 1)*step_count); break; } osDelay(4); } TRACE(1,"%s: done.",__func__); } #endif enum NORFLASH_ASYNC_CMD { NORFLASH_ASYNC_CMD_WRITE, NORFLASH_ASYNC_CMD_ERASE, NORFLASH_ASYNC_CMD_FLUSH, }; // regin[0]: start = 0x3c000000, end = 0x3c0cf000. -- code // regin[1]: start = 0x3c0cf000, end = 0x3c3ed000. -- __crash_dump // regin[2]: start = 0x3c3ed000, end = 0x3c3fd000. -- __custom_parameter // regin[3]: start = 0x3c3fe000, end = 0x3c3fe000. -- __aud // regin[4]: start = 0x3c3fe000, end = 0x3c3ff000. -- __userdata // regin[5]: start = 0x3c3ff000, end = 0x3c400000. -- __factory enum NORFLASH_ASYNC_STATE { NORFLASH_ASYNC_STATE_INIT, NORFLASH_ASYNC_STATE_ERASE, NORFLASH_ASYNC_STATE_WRITTING, NORFLASH_ASYNC_STATE_WAIT, NORFLASH_ASYNC_STATE_END, NORFLASH_ASYNC_STATE_FAILED, }; typedef struct { enum NORFLASH_ASYNC_STATE state; AT_FLASH_REGION_INFO *region; enum NORFLASH_API_MODULE_ID_T mod_id; uint32_t buff_len; uint32_t e_addr; uint32_t w_offs; uint32_t len_index; uint32_t succ_count; uint32_t fail_count; uint32_t tried_count; }ASYNC_SCENE; uint32_t g_at_len[] = {1,255,256,512,1024,2048}; ASYNC_SCENE at_async_scene[3] = { {NORFLASH_ASYNC_STATE_INIT,®ion_info[FLASH_REGION_ID_FREE],NORFLASH_API_MODULE_ID_FREE,AT_FLASH_SECTOR_SIZE*2,0,0,0,0,0,0}, {NORFLASH_ASYNC_STATE_INIT,®ion_info[FLASH_REGION_ID_CRASH_DUMP],NORFLASH_API_MODULE_ID_CRASH_DUMP,AT_FLASH_SECTOR_SIZE*2,0,0,0,0,0,0}, {NORFLASH_ASYNC_STATE_INIT,®ion_info[FLASH_REGION_ID_FACTORY],NORFLASH_API_MODULE_ID_FACTORY,AT_FLASH_SECTOR_SIZE*1,0,0,0,0,0,0} }; bool g_at_test_break; //uint8_t w_buff[AT_FLASH_SECTOR_SIZE]; //uint8_t r_buff[AT_FLASH_SECTOR_SIZE]; void at_w_buff_set(uint8_t* buff,uint32_t len) { uint32_t i; uint8_t val; val = 0; for(i= 0; i < len; i++) { buff[i] = val; val ++; } } uint32_t at_get_scene_index(uint32_t addr) { uint32_t i; for(i = 0; i < 3; i++) { if(addr >= at_async_scene[i].region->start_addr && addr < at_async_scene[i].region->end_addr) { return i; } } return i; } void at_user_func(uint32_t param0,uint32_t param1); void at_opera_result_notify(void* param) { NORFLASH_API_OPERA_RESULT *opera_result; enum NORFLASH_API_RET_T result; uint32_t offs; uint32_t index; uint32_t i; //enum THREAD_USER_ID user_id; //uint32_t suspend = 1; opera_result = (NORFLASH_API_OPERA_RESULT*)param; AT_TRACE(6,"%s:type = %d, addr = 0x%x,len = 0x%x,remain_num = %d,result = %d.", __func__, opera_result->type, opera_result->addr, opera_result->len, opera_result->remain_num, opera_result->result); // check. index = at_get_scene_index(opera_result->addr); ASSERT(index < 3, "%s:at_get_scene_index faile!,addr = 0x%x.",__func__,opera_result->addr); offs = (opera_result->addr&0xffffff) - ((opera_result->addr&0xffffff)/4096)*4096; if(opera_result->remain_num == 0) { result = norflash_sync_read(at_async_scene[index].mod_id,opera_result->addr,at_buff_r,opera_result->len); if(result != NORFLASH_API_OK) { ASSERT(0, "%s: hal_norflash_read failed, result = %d",__func__,result); } if(opera_result->type == NORFLASH_API_WRITTING) { if(memcmp(at_buff_r,at_buff_w + offs,opera_result->len) == 0) { AT_TRACE(4,"%s: writting read back check ok.addr = 0x%x,len = 0x%x, offs = 0x%x.", __func__,opera_result->addr,opera_result->len,offs); at_async_scene[index].succ_count ++; } else { uint32_t remain_len; AT_TRACE(4,"%s: writting read back check failed.addr = 0x%x,len = 0x%x,offs = 0x%x.", __func__,opera_result->addr,opera_result->len,offs); for(i = 0; i < opera_result->len/32; i++) { DUMP8("0x%02x, ",at_buff_r + i*32,32); DUMP8("0x%02x, ",at_buff_w + offs + i*32,32); } remain_len = opera_result->len - (opera_result->len/32)*32; if(remain_len > 0) { DUMP8("0x%02x, ",at_buff_r + i*32,remain_len); DUMP8("0x%02x, ",at_buff_w + offs + i*32,remain_len); } at_async_scene[index].fail_count ++; } } else { for(i = 0; i < AT_FLASH_SECTOR_SIZE; i++) { if(at_buff_r[i] != 0xff) { break; } } if(i == AT_FLASH_SECTOR_SIZE) { at_async_scene[index].succ_count ++; } else { AT_TRACE(1,"%s: erasing operation read back check failed.",__func__); at_async_scene[index].fail_count ++; } } } //user_id = (enum THREAD_USER_ID)index; //suspend = 1; //at_thread_user_enqueue_cmd(user_id,0,user_id,suspend,(uint32_t)at_user_func); } void at_user_func(uint32_t param0,uint32_t param1) { enum NORFLASH_API_RET_T result; ASYNC_SCENE *pscane; enum THREAD_USER_ID user_id; uint32_t suspend = 1; user_id = (enum THREAD_USER_ID)param0; suspend = param1; pscane = &at_async_scene[user_id]; pscane->state = NORFLASH_ASYNC_STATE_INIT; suspend = suspend; AT_TRACE(4,"%s,%d:user_id = %d,suspend = %d.",__func__,__LINE__,user_id,suspend); while(1) { if(g_at_test_break || pscane->fail_count > 0) { pscane->state = NORFLASH_ASYNC_STATE_END; break; } if(pscane->state == NORFLASH_ASYNC_STATE_INIT) { AT_TRACE(2,"%s,%d,NORFLASH_ASYNC_STATE_INIT",__func__,__LINE__); pscane->e_addr = pscane->region->start_addr; pscane->w_offs = 0; pscane->len_index = 0; pscane->succ_count = 0; pscane->fail_count = 0; pscane->tried_count = 0; pscane->state = NORFLASH_ASYNC_STATE_ERASE; } else if(pscane->state == NORFLASH_ASYNC_STATE_ERASE) { if(pscane->e_addr >= pscane->region->end_addr) { AT_TRACE(3,"%s,%d: NORFLASH_ASYNC_STATE_ERASE, has arrived to end_addr.addr = 0x%x", __func__, __LINE__, pscane->e_addr); pscane->state = NORFLASH_ASYNC_STATE_WAIT; continue; } result = norflash_api_erase(pscane->mod_id, pscane->e_addr, AT_FLASH_SECTOR_SIZE, true); if(result == NORFLASH_API_OK) { AT_TRACE(3,"%s,%d: NORFLASH_ASYNC_STATE_ERASE,erase ok!addr = 0x%x", __func__, __LINE__, pscane->e_addr); pscane->w_offs = 0; pscane->len_index = 0; pscane->state = NORFLASH_ASYNC_STATE_WRITTING; pscane->tried_count = 0; } else if(result == NORFLASH_API_BUFFER_FULL) { if(pscane->tried_count == 0) { AT_TRACE(3,"%s,%d: NORFLASH_ASYNC_STATE_ERASE,too more!addr = 0x%x", __func__, __LINE__, pscane->e_addr); } pscane->tried_count++; norflash_api_flush(); //osDelay(100); } else { AT_TRACE(4,"%s,%d: NORFLASH_ASYNC_STATE_ERASE,erase failed!addr = 0x%x,result = %d.", __func__, __LINE__, pscane->e_addr,result); } } else if(pscane->state == NORFLASH_ASYNC_STATE_WRITTING) { if(pscane->len_index >= sizeof(g_at_len)/sizeof(g_at_len[0])) { AT_TRACE(3,"%s,%d:NORFLASH_ASYNC_STATE_WRITTING,has arrived to sector end. w_offs = 0x%x", __func__, __LINE__, pscane->w_offs); pscane->e_addr += AT_FLASH_SECTOR_SIZE; pscane->state = NORFLASH_ASYNC_STATE_ERASE; continue; } if(norflash_api_get_used_buffer_count(pscane->mod_id,NORFLASH_API_ALL) > 0) { norflash_api_flush(); continue; } result = norflash_api_write(pscane->mod_id, pscane->e_addr + pscane->w_offs, at_buff_w + pscane->w_offs, g_at_len[pscane->len_index], true); if(result == NORFLASH_API_OK) { AT_TRACE(3,"%s,%d NORFLASH_ASYNC_STATE_WRITTING,norflash_api_write ok!addr = 0x%x", __func__, __LINE__, pscane->e_addr + pscane->w_offs); pscane->w_offs += g_at_len[pscane->len_index]; pscane->len_index ++; pscane->tried_count = 0; } else if(result == NORFLASH_API_BUFFER_FULL) { if(pscane->tried_count == 0) { AT_TRACE(3,"%s,%d: NORFLASH_ASYNC_STATE_WRITTING, too more!addr = 0x%x", __func__, __LINE__, pscane->e_addr + pscane->w_offs); } pscane->tried_count++; norflash_api_flush(); //osDelay(100); } else { AT_TRACE(4,"%s,%d: NORFLASH_ASYNC_STATE_WRITTING writting failed!addr = 0x%x,result = %d.", __func__, __LINE__, pscane->e_addr + pscane->w_offs, result); goto _func_fail; } } else if(pscane->state == NORFLASH_ASYNC_STATE_WAIT) { //AT_TRACE(2,"%s,%d,NORFLASH_ASYNC_STATE_WAIT",__func__,__LINE__); if(norflash_api_buffer_is_free(pscane->mod_id)) { AT_TRACE(2,"%s,%d: NORFLASH_ASYNC_STATE_WAIT,norflash_api_buffer_is_free is true.", __func__, __LINE__); pscane->state = NORFLASH_ASYNC_STATE_END; pscane->tried_count = 0; } else { if(pscane->tried_count == 0) { AT_TRACE(2,"%s,%d: NORFLASH_ASYNC_STATE_WAIT,norflash_api_buffer_is_free is false ", __func__, __LINE__); } pscane->tried_count++; norflash_api_flush(); //osDelay(100); } } else if(pscane->state == NORFLASH_ASYNC_STATE_END) { AT_TRACE(2,"%s,%d,NORFLASH_ASYNC_STATE_END",__func__,__LINE__); break; } } AT_TRACE(3,"%s,%d,user_id = %d",__func__,__LINE__,user_id); return; _func_fail: AT_TRACE(2,"%s: norflash_api failed! state = %d.", __func__, pscane->state); } void at_norflash_async_init(enum THREAD_USER_ID user_id) { ASYNC_SCENE *pscene; enum NORFLASH_API_RET_T result; uint32_t sector_size = 0; uint32_t block_size = 0; uint32_t page_size = 0; ASSERT(user_id < 3,"%s:user_id == %d.",__func__,user_id); AT_TRACE(3,"%s,%d: user_id = %d.",__func__,__LINE__,user_id); hal_norflash_get_size(HAL_NORFLASH_ID_0, NULL, &block_size, §or_size, &page_size); pscene = &at_async_scene[user_id]; result = norflash_api_register(pscene->mod_id, HAL_NORFLASH_ID_0, pscene->region->start_addr, pscene->region->end_addr - pscene->region->start_addr, block_size, sector_size, page_size, pscene->buff_len, at_opera_result_notify); ASSERT(result == NORFLASH_API_OK, "%s:user_id == %d,result = %d.",__func__,user_id,(int)result); } void at_norflash_suspend(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; uint32_t i; uint32_t start_time; static bool is_fst = true; param0 = param0; cmd_id = cmd_id; AT_TRACE(0,"I am at_norflash_suspend"); g_at_test_break = false; for(i = 0; i < sizeof(region_info)/sizeof(AT_FLASH_REGION_INFO); i++) { AT_TRACE(3,"regin[%d]: start = 0x%x, end = 0x%x.",region_info[i].id,region_info[i].start_addr,region_info[i].end_addr); } if(is_fst) { at_w_buff_set(at_buff_w,AT_FLASH_SECTOR_SIZE); at_norflash_async_init(THREAD_USER0); at_norflash_async_init(THREAD_USER1); // at_norflash_async_init(THREAD_USER2); is_fst = false; } if(!at_thread_user_is_inited(THREAD_USER0)) { at_thread_user_init(THREAD_USER0); } if(!at_thread_user_is_inited(THREAD_USER1)) { at_thread_user_init(THREAD_USER1); } // if(!at_thread_user_is_inited(THREAD_USER2)) { // at_thread_user_init(THREAD_USER2); } // param0: user_id // praram1: suspend osDelay(100); at_thread_user_enqueue_cmd(THREAD_USER0,0,THREAD_USER0,1,(uint32_t)at_user_func); //osDelay(100); at_thread_user_enqueue_cmd(THREAD_USER1,0,THREAD_USER1,1,(uint32_t)at_user_func); //osDelay(100); // at_thread_user_enqueue_cmd(THREAD_USER2,0,THREAD_USER2,1,(uint32_t)at_user_func); start_time = hal_sys_timer_get(); while(1) { if(TICKS_TO_MS(hal_sys_timer_get() - start_time) >= 1000*60) // timeout 60second { AT_TRACE(1,"%s: wait out time!"); break; } if(at_async_scene[0].state == NORFLASH_ASYNC_STATE_END && at_async_scene[1].state == NORFLASH_ASYNC_STATE_END ) { if(at_async_scene[0].fail_count == 0 && at_async_scene[1].fail_count == 0 ) { AUTO_TEST_SEND(AT_CMD_RESP_NORFLASH_SUSPEND); break; } else { break; } } else if(at_async_scene[0].fail_count > 0 || at_async_scene[1].fail_count > 0 ) { g_at_test_break = true; } else { AT_TRACE(2,"%s: is runnig.time = %d(ms).",__func__,TICKS_TO_MS(hal_sys_timer_get() - start_time)); osDelay(500); } } //_func_fail: // AT_TRACE(1,"_debug:Flash testing fail.error_code = %d.",error_code); } int32_t _at_memory_test(uint8_t* buff,uint32_t size) { uint8_t value; uint32_t i; int32_t ret = 0; value = 0; for(i = 0; i < size; i++) { buff[i] = value++; } value = 0; for(i = 0; i < size; i++) { if(buff[i] != value++) { ret = 2; goto _func_end; } } _func_end: return ret; } void at_memory(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; uint8_t *buff; uint8_t error_code = 1; int32_t result; error_code = error_code; //AT_TRACE(0,"_debug: I am at_memory"); buff = (uint8_t*)at_buff_r; result = _at_memory_test(buff,AT_FLASH_SECTOR_SIZE); if(result != 0) { error_code = 2; goto _func_fail; } buff = (uint8_t*)at_buff_w; result = _at_memory_test(buff,AT_FLASH_SECTOR_SIZE); if(result != 0) { error_code = 2; goto _func_fail; } buff = (uint8_t*)at_buff_b; result = _at_memory_test(buff,AT_FLASH_SECTOR_SIZE); if(result != 0) { error_code = 3; goto _func_fail; } error_code = 0; AUTO_TEST_SEND(AT_CMD_RESP_MEMORY); _func_fail: AT_TRACE(1,"_debug:Memory testing fail.error_code = %d.",error_code); } void at_get_mac(uint32_t param0,uint32_t param1) { unsigned char *btd_addr; btd_addr = bt_addr; if(NULL != btd_addr) { AT_TRACE(6,"GETMAC_TEST_OK:%x:%x:%x:%x:%x:%x",bt_addr[0],bt_addr[1],bt_addr[2],bt_addr[3],bt_addr[4],bt_addr[5]); AUTO_TEST_SEND(AT_CMD_RESP_MAC); } else { AT_TRACE(0,"GETMAC_TEST_NG!"); AUTO_TEST_SEND(AT_CMD_RESP_ERROR); } return; } void at_get_devicename(uint32_t param0,uint32_t param1) { const char *localname; localname = BT_LOCAL_NAME; if(NULL != localname) { AT_TRACE(1,"GETNAME_TEST_OK:%s",localname); } else { AT_TRACE(0,"GETNAME_TEST_NG!"); } return; } void at_set_loopback(uint32_t param0,uint32_t param1) { int idex; char *p; p = (char*)param0; idex = atoi(p); AT_TRACE(1,"[%s]", __func__); switch(idex) { case 1: app_audio_sendrequest(APP_FACTORYMODE_AUDIO_LOOP, (uint8_t)APP_BT_SETTING_OPEN, 0); AT_TRACE(0,"LOOPBACK_TEST_OPEN!"); AUTO_TEST_SEND(AT_CMD_RESP_LOOPBACK); break; case 2: app_audio_sendrequest(APP_FACTORYMODE_AUDIO_LOOP, (uint8_t)APP_BT_SETTING_CLOSE, 0); AT_TRACE(0,"LOOPBACK_TEST_CLOSED!"); AUTO_TEST_SEND(AT_CMD_RESP_LOOPBACK); break; default: AT_TRACE(1,"LOOPBACK_TEST param error: %s!",idex); AUTO_TEST_SEND(AT_CMD_RESP_ERROR); } return; } void at_set_led(uint32_t param0,uint32_t param1) { char *p; p = (char*)param0; switch(*p) { case 0x31://'1': AT_TRACE(0,"LED light 1"); app_status_indication_set(APP_STATUS_INDICATION_CHARGING); AUTO_TEST_SEND(AT_CMD_RESP_LED); break; case 0x32://'2': AT_TRACE(0,"LED light 2"); app_status_indication_set(APP_STATUS_INDICATION_FULLCHARGE); AUTO_TEST_SEND(AT_CMD_RESP_LED); break; default: AT_TRACE(0,"LED light all"); app_status_indication_set(APP_STATUS_INDICATION_TESTMODE); AUTO_TEST_SEND(AT_CMD_RESP_LED); break; } AT_TRACE(0,"SETLED_TEST_OK!"); return ; } void at_enter_signaling_mode(uint32_t param0,uint32_t param1) { AT_TRACE(1,"%s",__func__); hal_sw_bootmode_set(HAL_SW_BOOTMODE_TEST_MODE|HAL_SW_BOOTMODE_TEST_SIGNALINGMODE); app_reset(); } void at_enter_no_signaling_mode(uint32_t param0,uint32_t param1) { AT_TRACE(1,"[%s]", __func__); hal_sw_bootmode_set(HAL_SW_BOOTMODE_TEST_MODE|HAL_SW_BOOTMODE_TEST_NOSIGNALINGMODE); app_reset(); } const uint8_t hci_cmd_nonsig_ble_stop_pn9[] = { 0x01, 0x1f, 0x20, 0x00 }; const uint8_t hci_cmd_stop_bt_no_signaling_test_configuration[] = { 0x01, 0x87, 0xfc, 0x14, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; const uint8_t hci_cmd_ble_no_signaling_test_configuration[3][7] = { // 2402-----INDEX0 tx {0x01, 0x1e, 0x20, 0x03, 0x00, 0x25, 0x03}, // 2440-----INDEX1 {0x01, 0x1e, 0x20, 0x03, 0x13, 0x25, 0x03}, // 2480-----INDEX2 {0x01, 0x1e, 0x20, 0x03, 0x27, 0x25, 0x03}, }; const uint8_t hci_cmd_ble_rx_no_signaling_test_configuration[3][5] = { // 2402-----INDEX0 rx {0x01, 0x1d, 0x20, 0x01, 0x00}, // 2440-----INDEX1 {0x01, 0x1d, 0x20, 0x01, 0x13}, // 2480-----INDEX2 {0x01, 0x1d, 0x20, 0x01, 0x27}, }; const uint8_t hci_cmd_bt_no_signaling_test_configuration[24][24] = { // BR DH3, 2402, TX-----INDEX0 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0b, 0x04, 0xB7, 0x00}, // BR DH3, 2402, RX-----INDEX1 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0b, 0x04, 0xb7, 0x00}, // BR DH3, 2441, TX-----INDEX2 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x27, 0x27, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0b, 0x04, 0xB7, 0x00}, // BR DH3, 2441, RX-----INDEX3 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x27, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0b, 0x04, 0xb7, 0x00}, // BR DH3, 2480, TX-----INDEX4 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x4e, 0x4e, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0b, 0x04, 0xB7, 0x00}, // BR DH3, 2480, RX-----INDEX5 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x4e, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0b, 0x04, 0xb7, 0x00}, // BR DH5, 2402, TX-----INDEX6 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0f, 0x04, 0x53, 0x01}, // BR DH5, 2402, RX-----INDEX7 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0f, 0x04, 0x53, 0x01}, // BR DH5, 2441, TX-----INDEX8 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x27, 0x27, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0f, 0x04, 0x53, 0x01}, // BR DH5, 2441, RX-----INDEX9 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x27, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0f, 0x04, 0x53, 0x01}, // BR DH5, 2480, TX-----INDEX10 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x4e, 0x4e, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0f, 0x04, 0x53, 0x01}, // BR DH5, 2480, RX-----INDEX11 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x4e, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x0f, 0x04, 0x53, 0x01}, // BR 2DH5, 2402, TX----INDEX12 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0e, 0x04, 0xa7, 0x02}, // BR 2DH5, 2402, RX----INDEX13 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0e, 0x04, 0xa7, 0x02}, // BR 2DH5, 2441, TX----INDEX14 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x27, 0x27, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0e, 0x04, 0xa7, 0x02}, // BR 2DH5, 2441, RX----INDEX15 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x27, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0e, 0x04, 0xa7, 0x02}, // BR 2DH5, 2480, TX----INDEX16 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x4e, 0x4e, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0e, 0x04, 0xa7, 0x02}, // BR 2DH5, 2480, RX----INDEX17 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x4e, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0e, 0x04, 0xa7, 0x02}, // BR 3DH5, 2402, TX----INDEX18 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0f, 0x04, 0xfd, 0x03}, // BR 3DH5, 2402, RX----INDEX19 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0f, 0x04, 0xfd, 0x03}, // BR 3DH5, 2441, TX----INDEX20 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x27, 0x27, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0f, 0x04, 0xfd, 0x03}, // BR 3DH5, 2441, RX----INDEX21 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x27, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0f, 0x04, 0xfd, 0x03}, // BR 3DH5, 2480, TX----INDEX22 {0x01, 0x87, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x4e, 0x4e, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0f, 0x04, 0xfd, 0x03}, // BR 3DH5, 2480, RX----INDEX23 {0x01, 0x87, 0xfc, 0x14, 0x01, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x4e, 0x02, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x01, 0x0f, 0x04, 0xfd, 0x03}, }; static const uint8_t hci_cmd_nonsig_tx_dh1_pn9[] = { 0x01, 0x60, 0xfc, 0x14, 0x00, 0xe8, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x01, 0x00, 0x04, 0x04, 0x1b, 0x00 }; void BleFrequencyTestStop() { btdrv_SendData(hci_cmd_nonsig_ble_stop_pn9, sizeof(hci_cmd_nonsig_ble_stop_pn9)); } void BtFrequencyTestStop() { btdrv_SendData(hci_cmd_stop_bt_no_signaling_test_configuration, sizeof(hci_cmd_stop_bt_no_signaling_test_configuration)); } void BleFrequencyTestStart(uint8_t index) { TRACE(2,"[%s] index is %d", __func__, index); btdrv_SendData(hci_cmd_ble_no_signaling_test_configuration[index], sizeof(hci_cmd_ble_no_signaling_test_configuration[0])); } void BleFrequencyTestStartRx(uint8_t index) { TRACE(2,"[%s] index is %d", __func__, index); btdrv_SendData(hci_cmd_ble_rx_no_signaling_test_configuration[index], sizeof(hci_cmd_ble_rx_no_signaling_test_configuration[0])); } void BtFrequencyTestStart(uint8_t index) { TRACE(2,"[%s] index is %d", __func__, index); if (index < sizeof(hci_cmd_bt_no_signaling_test_configuration)/sizeof(hci_cmd_bt_no_signaling_test_configuration[0])) { btdrv_SendData(hci_cmd_bt_no_signaling_test_configuration[index], sizeof(hci_cmd_bt_no_signaling_test_configuration[0])); } else { btdrv_SendData(hci_cmd_nonsig_tx_dh1_pn9, sizeof(hci_cmd_nonsig_tx_dh1_pn9)); } } void at_no_signaling_ble_test(uint32_t param0,uint32_t param1) { AT_TRACE(1,"[%s]", __func__); char *p; p = (char*)param0; switch(*p) { case RF_CHANNEL_BLE_STOP: { BleFrequencyTestStop(); break; } case RF_FREQUENCY_2402: { BleFrequencyTestStart(0); break; } case RF_FREQUENCY_2440: { BleFrequencyTestStart(1); break; } case RF_FREQUENCY_2480: { BleFrequencyTestStart(2); break; } case RF_FREQUENCY_2402_RX: { BleFrequencyTestStartRx(0); break; } case RF_FREQUENCY_2440_RX: { BleFrequencyTestStartRx(1); break; } case RF_FREQUENCY_2480_RX: { BleFrequencyTestStartRx(2); break; } default: break; } return; } void at_no_signaling_bt_test(uint32_t param0,uint32_t param1) { AT_TRACE(1,"[%s]", __func__); int idex; char *p; p = (char*)param0; idex = atoi(p); BtFrequencyTestStart(idex); return; } void at_get_battery(uint32_t param0,uint32_t param1) { AT_TRACE(1,"[%s]", __func__); uint16_t batteryInfo = 0; int getstatus = app_battery_get_info( &batteryInfo,NULL, NULL); if(getstatus) { AUTO_TEST_SEND(AT_CMD_RESP_ERROR); } else { AT_TRACE(1,"battery voltage:%d mV",batteryInfo); AUTO_TEST_SEND(AT_CMD_RESP_BATTERY); } return; } void at_set_volume(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; int idex; char *p; AT_TRACE(0,"_debug: I at_set_volume"); p = (char*)param0; idex = atoi(p); AT_TRACE(1,"_debug: volume set: %d",idex); if(idex > TGT_VOLUME_LEVEL_15 ) { idex = 17; } if(idex < TGT_VOLUME_LEVEL_MUTE ) { idex = 1; } //app_bt_set_volume(APP_BT_STREAM_HFP_PCM,idex); app_bt_set_volume(APP_BT_STREAM_A2DP_SBC,idex); //btapp_hfp_report_speak_gain(); btapp_a2dp_report_speak_gain(); _at_resp(); return; } void at_get_fwversion(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; uint8_t fw_rev[4]; AT_TRACE(0,"_debug: I at_get_fwversion"); system_get_fwversion(&fw_rev[0], &fw_rev[1], &fw_rev[2], &fw_rev[3]); AT_TRACE(4,"_debug: FwVersion: %d.%d.%d.%d",fw_rev[0], fw_rev[1], fw_rev[2], fw_rev[3]); AUTO_TEST_SEND(AT_CMD_RESP_FWVER); _at_resp(); return; } void at_get_bootmode(uint32_t param0,uint32_t param1) { AT_CMD_ID_ENUM_T cmd_id = (AT_CMD_ID_ENUM_T)param1; cmd_id = cmd_id; uint32_t bootmode; AT_TRACE(0,"_debug: I at_get_bootmode"); bootmode = hal_sw_bootmode_get(); AT_TRACE(1,"_debug: bootmode: 0x%x.",bootmode); AUTO_TEST_SEND(AT_CMD_RESP_BOOTMODE); _at_resp(); return; } int32_t at_Init(void) { int32_t ret; AT_TRACE(0,"at_Init."); ret = at_os_init(); return ret; } #endif// (_AUTO_TEST_)