rudism/pinebuds
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
pinebuds/services/auto_test/auto_test.cpp
Ben V. Brown 75381150fd Formatting 
Formatting Pass 1

Lots of fixups to adding stdint and stdbool all over the place

Formatting Pass 2
Formatting Pass 3
Formatting Pass 4

Update app_bt_stream.cpp
2023-02-02 07:56:49 +11:00

2219 lines
70 KiB
C++
Raw Blame History

/***************************************************************************
*
* 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 "app_status_ind.h"
#include "app_thread.h"
#include "apps.h"
#include "cmsis_os.h"
#include "hal_aud.h"
#include "hal_chipid.h"
#include "hal_key.h"
#include "hal_timer.h"
#include "hal_trace.h"
#include "nvrecord.h"
#include "pmu.h"
extern "C" {
#include "besbt_cfg.h"
#ifndef ENHANCED_STACK
#include "avrcpi.h"
#include "eventmgr.h"
#include "me.h"
#include "sec.h"
#include "sys/mei.h"
#endif
#include "a2dp.h"
#include "avctp.h"
#include "avdtp.h"
#include "avrcp.h"
}
#include "app_bt.h"
#include "app_utils.h"
#include "at_thread.h"
#include "at_thread_user.h"
#include "btapp.h"
#include "hal_norflash.h"
#include "norflash_api.h"
#include "app_a2dp.h"
#include "app_audio.h"
#include "app_battery.h"
#include "app_bt_stream.h"
#include "app_hfp.h"
#include "bt_drv_interface.h"
#include "hal_bootmode.h"
#include "hal_sleep.h"
#include "tgt_hardware.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_)
Reference in a new issue View git blame Copy permalink