rudism
/
pinebuds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pinebuds/services/auto_test/auto_test.cpp

2437 lines
76 KiB
C++
Raw Normal View History

add first commit
2022-08-15 04:20:27 -05:00
/***************************************************************************
*
* 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 <ANY_STRING>
// SWITCH_FREQ SWITCH_FREQ<n><m> Switch freq ok.
// SIMULATE_KEY SIMULATE_KEY=<code>,<event> 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 "<ANY_STRING>"
#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 &region_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,&region_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,&region_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,&region_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,
&sector_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_)