216 lines
7.0 KiB
C
216 lines
7.0 KiB
C
/*
|
|
* Copyright (c) CompanyNameMagicTag 2018-2020. All rights reserved.
|
|
* Description: APP code for DUT test.
|
|
*/
|
|
|
|
#include "app_sta_dut.h"
|
|
#if defined(PRODUCT_CFG_PRODUCT_TYPE_STA)
|
|
#include "app_proto_645.h"
|
|
#include "app_main.h"
|
|
#include "app_common.h"
|
|
#include "app_uart.h"
|
|
#include "string.h"
|
|
#include "securec.h"
|
|
#include "soc_mdm_mem.h"
|
|
#include "soc_ft_nv.h"
|
|
#include "soc_mdm_phy.h"
|
|
#include "soc_mdm_nv.h"
|
|
|
|
/* frame datagram */
|
|
/* +----+-----------+----+----+----+-------------+------+----+----+ */
|
|
/* |head|address(6) |head|ctrl|len | (di 4) | DATA | CS |tail| */
|
|
/* +----+-----------+----+----+----+-------------+------+----+----+ */
|
|
/* | 68 | a5 ... a0 | 68 | xx | xx | di3 ... di0 | DATA | CS | 16 | */
|
|
/* +----+-----------+----+----+----+-------------+------+----+----+ */
|
|
#define DI_FEFF1202 (0x31324535) /* set configuration. 'FEFF1202' + '33' */
|
|
|
|
#define DUT_POWER_STEP_SIZE (4)
|
|
|
|
typedef struct {
|
|
td_u8 stru_ver;
|
|
td_u8 stru_size;
|
|
td_u8 dut_mac[EXT_PLC_MAC_ADDR_LEN];
|
|
td_u8 mac[EXT_PLC_MAC_ADDR_LEN];
|
|
td_s8 power_step;
|
|
td_u8 afe_gain;
|
|
} dut_mac_wrt_req;
|
|
|
|
typedef struct {
|
|
td_u8 stru_ver;
|
|
td_u8 stru_size;
|
|
td_u16 dut_mac_ret : 4;
|
|
td_u16 mac_ret : 4;
|
|
td_u16 power_reduce_ret : 4;
|
|
td_u16 reserved : 4;
|
|
} dut_mac_wrt_ind;
|
|
|
|
td_u32 app_dut_feff1202(td_pbyte frame, td_u16 length);
|
|
td_u32 dut_set_mac_addr(td_u8 mac[EXT_PLC_MAC_ADDR_LEN]);
|
|
td_u32 dut_write_mac_2_nv(EXT_CONST td_u8 mac[EXT_PLC_MAC_ADDR_LEN]);
|
|
td_void dut_reply(td_u32 di, td_pbyte data, td_u8 data_length);
|
|
|
|
td_bool app_handle_dut_frame(EXT_CONST td_pbyte frame, td_u16 length)
|
|
{
|
|
td_u32 ret;
|
|
td_u16 start_pos = 0;
|
|
td_u16 frame_length = 0;
|
|
td_u8 dut_addr[] = { 0xCC, 0xCC, 0xCC, 0xCC, 0xCC, 0xCC };
|
|
td_u32 di = 0;
|
|
|
|
ret = app_find_frame_645((td_pbyte)frame, length, &start_pos, &frame_length);
|
|
if (ret != EXT_ERR_SUCCESS) {
|
|
return TD_FALSE;
|
|
}
|
|
|
|
/* check frame 645 length: the frame must contail 'DI' filed. */
|
|
if (frame_length < PROTO_645_DATAGRAM_LEN_MIN + sizeof(di)) {
|
|
return TD_FALSE;
|
|
}
|
|
|
|
/* check frame 645 address filed: \xCC\xCC\xCC\xCC\xCC\xCC */
|
|
if (memcmp(dut_addr, frame + start_pos + 1, sizeof(dut_addr)) != 0) {
|
|
/* Not dut frame. */
|
|
return TD_FALSE;
|
|
}
|
|
|
|
/* process di */
|
|
(td_void) memcpy_s(&di, sizeof(di), frame + start_pos + APP_DUT_DI_BYTE_OFFSET, APP_DUT_DI_LEN);
|
|
if (di == DI_FEFF1202) {
|
|
ret = app_dut_feff1202(frame + start_pos, frame_length);
|
|
return (ret == EXT_ERR_SUCCESS) ? TD_TRUE : TD_FALSE;
|
|
}
|
|
|
|
return TD_FALSE;
|
|
}
|
|
|
|
td_u32 app_dut_feff1202(td_pbyte frame, td_u16 length)
|
|
{
|
|
td_u32 ret;
|
|
dut_mac_wrt_req *dut_mac_inf = TD_NULL;
|
|
dut_mac_wrt_ind dut_ret;
|
|
|
|
if (length < sizeof(td_u32) + sizeof(dut_mac_wrt_req) + PROTO_645_DATAGRAM_LEN_MIN) {
|
|
return EXT_ERR_INVALID_PARAMETER;
|
|
}
|
|
|
|
dut_mac_inf = (dut_mac_wrt_req *)uapi_malloc(EXT_MOD_ID_APP_COMMON, sizeof(dut_mac_wrt_req));
|
|
if (dut_mac_inf == TD_NULL) {
|
|
return EXT_ERR_MALLOC_FAILUE;
|
|
}
|
|
|
|
(td_void) memcpy_s(dut_mac_inf, sizeof(dut_mac_wrt_req),
|
|
frame + APP_DUT_MAC_BYTE_OFFSET, sizeof(dut_mac_wrt_req));
|
|
app_frame_645_decode((td_pbyte)dut_mac_inf, sizeof(dut_mac_wrt_req));
|
|
|
|
if (length != sizeof(td_u32) + dut_mac_inf->stru_size + PROTO_645_DATAGRAM_LEN_MIN) {
|
|
uapi_free(EXT_MOD_ID_APP_COMMON, dut_mac_inf);
|
|
dut_mac_inf = TD_NULL;
|
|
return EXT_ERR_INVALID_PARAMETER;
|
|
}
|
|
|
|
dut_ret.stru_ver = 0;
|
|
dut_ret.stru_size = sizeof(dut_ret);
|
|
dut_ret.dut_mac_ret = 0xF;
|
|
dut_ret.mac_ret = 0xF;
|
|
dut_ret.power_reduce_ret = 0xF;
|
|
dut_ret.reserved = 0;
|
|
|
|
do {
|
|
app_timer_stop(APP_TIMER_ID_INIT);
|
|
ret = app_set_mac_addr(dut_mac_inf->dut_mac, sizeof(dut_mac_inf->dut_mac));
|
|
if (ret != EXT_ERR_SUCCESS) {
|
|
break;
|
|
}
|
|
|
|
dut_ret.dut_mac_ret = 0;
|
|
|
|
ret = dut_write_mac_2_nv(dut_mac_inf->mac);
|
|
if (ret != EXT_ERR_SUCCESS) {
|
|
break;
|
|
}
|
|
|
|
dut_ret.mac_ret = 0;
|
|
|
|
uapi_set_power_step(dut_mac_inf->power_step);
|
|
uapi_set_afe_pga_gain(dut_mac_inf->afe_gain);
|
|
dut_ret.power_reduce_ret = 0;
|
|
} while (0);
|
|
|
|
uapi_free(EXT_MOD_ID_APP_COMMON, dut_mac_inf);
|
|
dut_mac_inf = TD_NULL;
|
|
|
|
dut_reply(0xfeff1202, (td_pbyte)&dut_ret, sizeof(dut_ret));
|
|
|
|
return EXT_ERR_FAILURE;
|
|
}
|
|
|
|
td_void dut_reply(td_u32 di, td_pbyte data, td_u8 length)
|
|
{
|
|
td_u8 data_length = sizeof(td_u32) + length;
|
|
td_u8 payload_length = PROTO_645_DATAGRAM_LEN_MIN + data_length;
|
|
td_u8 *payload = TD_NULL;
|
|
td_u8 *buffer = TD_NULL;
|
|
|
|
if (data == TD_NULL) {
|
|
return;
|
|
}
|
|
payload = (td_u8 *)uapi_malloc(EXT_MOD_ID_APP_COMMON, payload_length + APP_DUT_PAYLOAD_LEN);
|
|
if (payload == TD_NULL) {
|
|
return;
|
|
}
|
|
buffer = payload + APP_DUT_PAYLOAD_LEN;
|
|
payload[0] = APP_DUT_REPLY_DATA;
|
|
payload[APP_DUT_PAYLOAD_INDEX1] = APP_DUT_REPLY_DATA;
|
|
payload[APP_DUT_PAYLOAD_INDEX2] = APP_DUT_REPLY_DATA;
|
|
payload[APP_DUT_PAYLOAD_INDEX3] = APP_DUT_REPLY_DATA;
|
|
|
|
buffer[0] = PROTO_645_HEAD_BYTE;
|
|
(td_void) memset_s(buffer + 1, payload_length - 1, APP_DUT_BUF_DATA1, APP_DUT_BUF_LEN1);
|
|
buffer[APP_DUT_BUF_INDEX7] = PROTO_645_HEAD_BYTE;
|
|
buffer[APP_DUT_BUF_INDEX8] = APP_DUT_BUF_INDEX8_DATA;
|
|
buffer[APP_DUT_BUF_INDEX9] = data_length;
|
|
(td_void) memcpy_s(buffer + APP_DUT_BUF_LEN2, payload_length - APP_DUT_BUF_LEN2, &di, sizeof(td_u32));
|
|
(td_void) memcpy_s(buffer + APP_DUT_BUF_LEN3, payload_length - APP_DUT_BUF_LEN3, data, length);
|
|
app_frame_645_encode(buffer + APP_DUT_BUF_LEN2, data_length);
|
|
|
|
buffer[payload_length - APP_DUT_BUF_CHECKSUM_LEN] = app_tools_checksum8(buffer,
|
|
payload_length - APP_DUT_BUF_CHECKSUM_LEN);
|
|
buffer[payload_length - 1] = PROTO_645_TAIL_BYTE;
|
|
|
|
app_uart_tx(payload, payload_length + APP_DUT_PAYLOAD_LEN);
|
|
|
|
uapi_free(EXT_MOD_ID_APP_COMMON, payload);
|
|
payload = TD_NULL;
|
|
|
|
return;
|
|
}
|
|
|
|
td_u32 dut_write_mac_2_nv(EXT_CONST td_u8 mac[EXT_PLC_MAC_ADDR_LEN])
|
|
{
|
|
ext_nv_ftm_product_id *nv = TD_NULL;
|
|
td_u32 ret;
|
|
|
|
if (mac == TD_NULL) {
|
|
return EXT_ERR_FAILURE;
|
|
}
|
|
nv = (ext_nv_ftm_product_id *)uapi_malloc(EXT_MOD_ID_APP_COMMON, sizeof(ext_nv_ftm_product_id));
|
|
if (nv == TD_NULL) {
|
|
return EXT_ERR_MALLOC_FAILUE;
|
|
}
|
|
|
|
ret = uapi_factory_nv_read(EXT_NV_FTM_PRODUCT_ID, nv, sizeof(ext_nv_ftm_product_id));
|
|
if (ret == EXT_ERR_SUCCESS) {
|
|
if (memcpy_s(nv->plc_mac, EXT_PLC_MAC_ADDR_LEN, mac, EXT_PLC_MAC_ADDR_LEN) != EXT_ERR_SUCCESS) {
|
|
uapi_free(EXT_MOD_ID_APP_COMMON, nv);
|
|
return EXT_ERR_FAILURE;
|
|
}
|
|
ret = uapi_factory_nv_write(EXT_NV_FTM_PRODUCT_ID, nv, sizeof(ext_nv_ftm_product_id));
|
|
}
|
|
|
|
uapi_free(EXT_MOD_ID_APP_COMMON, nv);
|
|
nv = TD_NULL;
|
|
|
|
return ret;
|
|
}
|
|
|
|
#endif |