1328 lines
39 KiB
C
1328 lines
39 KiB
C
#include "system/includes.h"
|
||
#include "wifi/wifi_connect.h"
|
||
#include "app_config.h"
|
||
#include "device/uart.h"
|
||
|
||
#ifdef CONFIG_WIFIBOX_ENABLE
|
||
#include "client.h"
|
||
|
||
#ifdef WBCP_DEBUG_ENABLE
|
||
#define log_info(x, ...) printf("[WBCP][INFO]" x " ", ## __VA_ARGS__)
|
||
#define log_err(x, ...) printf("[WBCP][ERR]" x " ", ## __VA_ARGS__)
|
||
#else
|
||
#define log_info(...)
|
||
#define log_err(...)
|
||
#endif
|
||
|
||
#define LOCK_TX_PACKET() (os_mutex_pend(&wbcp.tx_mutex, 0))
|
||
#define UNLOCK_TX_PACKET() (os_mutex_post(&wbcp.tx_mutex))
|
||
|
||
static u8 user_handler_task[64] = {0};
|
||
static void (*wbcp_audio_data_user_handler)(void *priv) = NULL;
|
||
|
||
typedef struct GNU_PACKED {
|
||
/* Word 0 */
|
||
u32 WirelessCliID: 8;
|
||
u32 KeyIndex: 2;
|
||
u32 BSSID: 3;
|
||
u32 UDF: 3;
|
||
u32 MPDUtotalByteCount: 12;
|
||
u32 TID: 4;
|
||
/* Word 1 */
|
||
u32 FRAG: 4;
|
||
u32 SEQUENCE: 12;
|
||
u32 MCS: 7;
|
||
u32 BW: 1;
|
||
u32 ShortGI: 1;
|
||
u32 STBC: 2;
|
||
u32 rsv: 3;
|
||
u32 PHYMODE: 2; /* 1: this RX frame is unicast to me */
|
||
/*Word2 */
|
||
u32 RSSI0: 8;
|
||
u32 RSSI1: 8;
|
||
u32 RSSI2: 8;
|
||
u32 rsv1: 8;
|
||
/*Word3 */
|
||
u32 SNR0: 8;
|
||
u32 SNR1: 8;
|
||
u32 FOFFSET: 8;
|
||
u32 rsv2: 8;
|
||
/*UINT32 rsv2:16;*/
|
||
} RXWI_STRUC, *PRXWI_STRUC;
|
||
|
||
|
||
enum {
|
||
START_SEND_MSG,
|
||
SEND_PACKET_MSG,
|
||
};
|
||
|
||
|
||
static struct {
|
||
u8 start;
|
||
s32 count;
|
||
s32 num;
|
||
s32 pwr_sum;
|
||
s32 evm_sum;
|
||
s32 freq_sum;
|
||
u8 send_test_flag;
|
||
OS_SEM stat_sem;
|
||
OS_SEM test_sem;
|
||
stat_res_type stat_res;
|
||
} stat_prop;
|
||
|
||
static struct {
|
||
u8 mode;
|
||
u8 assist_flag;
|
||
u8 build_conn;
|
||
u8 enter;
|
||
u8 exit;
|
||
u8 shield;
|
||
u8 respond_flag;
|
||
u8 send_withack_flag;
|
||
OS_MUTEX tx_mutex;
|
||
OS_MUTEX ack_mutex;
|
||
OS_SEM tx_sem;
|
||
OS_SEM respond_sem;
|
||
wbcp_tx_packet_type tx_packet;
|
||
wbcp_tx_packet_type ack_packet;
|
||
} wbcp = {0};
|
||
|
||
static wbcp_conn_params_type conn_params;
|
||
|
||
static u8 BROADCAST_MAC[MAC_ADDR_SIZE] = {0x8A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F};
|
||
static u8 LOCAL_MAC[MAC_ADDR_SIZE] = {0};
|
||
static u8 REMOTE_MAC[MAC_ADDR_SIZE] = {0};
|
||
|
||
extern unsigned char bbp_rd(unsigned char adr);
|
||
static void wbcp_send_ack(wbcp_payload_type *payload, u8 *dest_mac, u8 mcs, u8 phymode);
|
||
static s8 wbcp_respond_conn_req(void);
|
||
static s8 wbcp_send_event_data(event_data_type *event_data, u8 *dest_mac, u8 ack);
|
||
static s32 wbcp_update_seach_status(u8 type, u8 ch);
|
||
static void conn_params_show(void *priv);
|
||
static s32 wbcp_update_event_to_user_handler(u8 type, s32 msg_size, s32 *msg);
|
||
static s8 wifi_init(void);
|
||
|
||
|
||
typedef struct {
|
||
u16 crc;
|
||
wbcp_payload_type payload;
|
||
} assist_data_type;
|
||
|
||
static u8 assist_stop_flag = 0;
|
||
static u32 assist_idx = 0;
|
||
static OS_SEM assist_sem;
|
||
|
||
static void *uart_hdl = NULL;
|
||
static u8 uart_buf[5 * 1024] __attribute__((aligned(32)));
|
||
|
||
|
||
static void assist_tx_task(void *priv)
|
||
{
|
||
u8 retry_cnt = 0;
|
||
assist_data_type tx_data;
|
||
|
||
tx_data.payload.version = WBCP_VERSION_ID;
|
||
tx_data.payload.type = EVENT_DATA_TYPE;
|
||
tx_data.payload.ack = 0;
|
||
tx_data.payload.seq = 0;
|
||
tx_data.payload.idx = ++assist_idx;
|
||
memcpy(&tx_data.payload.wbcp_data, (u8 *)priv, sizeof(wbcp_data_type));
|
||
tx_data.crc = CRC16(&tx_data.payload, sizeof(wbcp_payload_type));
|
||
|
||
for (;;) {
|
||
s32 send_ret = dev_write(uart_hdl, &tx_data, sizeof(assist_data_type));
|
||
log_info("assist retry_cnt = %d, send_ret = %d", retry_cnt, send_ret);
|
||
retry_cnt++;
|
||
os_time_dly(5);
|
||
if (assist_stop_flag) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
static u32 assist_tx_data(void *event_data)
|
||
{
|
||
u32 ret = 0;
|
||
|
||
assist_stop_flag = 0;
|
||
/* task_create(assist_tx_task, event_data, "assist_tx"); */
|
||
thread_fork("assist_tx_task", 12, 512, 0, NULL, assist_tx_task, event_data);
|
||
|
||
os_sem_set(&assist_sem, 0);
|
||
if (os_sem_pend(&assist_sem, 50) != OS_NO_ERR) {
|
||
log_err("assist tx timeout");
|
||
ret = 0;
|
||
} else {
|
||
ret = sizeof(event_data_type);
|
||
}
|
||
|
||
assist_stop_flag = 1;
|
||
task_kill("assist_tx");
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
static void assist_data_handler(event_data_type *data)
|
||
{
|
||
s32 msg;
|
||
|
||
log_info("assist event = %d\n", data->event);
|
||
if (data->event == ENTER_TEST_EVENT) {
|
||
switch (wbcp.mode) {
|
||
case WB_SERVER_MODE:
|
||
wbcp.enter = 1;
|
||
memcpy(REMOTE_MAC, data->params.conn_params.mac, MAC_ADDR_SIZE);
|
||
msg = (s32)&REMOTE_MAC[0];
|
||
wbcp_update_event_to_user_handler(ENTER_TEST_SUCC_MSG, 1, &msg);
|
||
break;
|
||
|
||
case WB_CLIENT_MODE:
|
||
memcpy(REMOTE_MAC, data->params.conn_params.mac, MAC_ADDR_SIZE);
|
||
memcpy(&conn_params, &data->params.conn_params, WBCP_CONN_PARAMS_SIZE);
|
||
conn_params_show(&conn_params);
|
||
os_sem_post(&wbcp.respond_sem);
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
} else {
|
||
wbcp_update_event_to_user_handler(NEW_EVENT_MSG, WBCP_EVENT_DATA_SIZE / sizeof(s32), (s32 *)data);
|
||
}
|
||
}
|
||
|
||
|
||
static void assist_rx_task(void *priv)
|
||
{
|
||
u16 crc;
|
||
u32 len = 0;
|
||
assist_data_type rx_data = {0};
|
||
u32 last_event_idx = 0, last_ack_idx = 0;
|
||
|
||
for (;;) {
|
||
memset(&rx_data, 0, sizeof(assist_data_type));
|
||
len = dev_read(uart_hdl, &rx_data, sizeof(assist_data_type));
|
||
if (len == UART_CIRCULAR_BUFFER_WRITE_OVERLAY) {
|
||
log_err("UART_CIRCULAR_BUFFER_WRITE_OVERLAY");
|
||
dev_ioctl(uart_hdl, UART_FLUSH, 0);
|
||
continue;
|
||
}
|
||
|
||
if (len == sizeof(assist_data_type)) {
|
||
crc = CRC16(&rx_data.payload, sizeof(wbcp_payload_type));
|
||
if (rx_data.crc != crc || !crc) {
|
||
/* log_err("assist rx_data crc err, rx_data.crc = %d, crc = %d\n", rx_data.crc, crc); */
|
||
continue;
|
||
}
|
||
|
||
switch (rx_data.payload.type) {
|
||
case RESP_DATA_TYPE:
|
||
if (rx_data.payload.idx != last_ack_idx) {
|
||
os_sem_post(&assist_sem);
|
||
last_ack_idx = rx_data.payload.idx;
|
||
} else {
|
||
log_err("the same assist ack\n");
|
||
}
|
||
break;
|
||
|
||
case EVENT_DATA_TYPE:
|
||
rx_data.payload.type = RESP_DATA_TYPE;
|
||
rx_data.crc = CRC16(&rx_data.payload, sizeof(wbcp_payload_type));
|
||
dev_write(uart_hdl, &rx_data, sizeof(assist_data_type));
|
||
if (rx_data.payload.idx != last_event_idx || rx_data.payload.wbcp_data.event_data.event == ENTER_TEST_EVENT) {
|
||
/* put_buf(&rx_data.payload.wbcp_data, sizeof(wbcp_data_type)); */
|
||
last_event_idx = rx_data.payload.idx;
|
||
assist_data_handler(&rx_data.payload.wbcp_data.event_data);
|
||
} else {
|
||
log_err("the same assist event\n");
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
static u8 assist_dev_init(void)
|
||
{
|
||
uart_hdl = dev_open(WB_ASSIST_UART, NULL);
|
||
if (!uart_hdl) {
|
||
log_err("special uart init fail");
|
||
return -1;
|
||
} else {
|
||
log_err("special uart init succ");
|
||
}
|
||
dev_ioctl(uart_hdl, UART_SET_CIRCULAR_BUFF_ADDR, (int)uart_buf);
|
||
dev_ioctl(uart_hdl, UART_SET_CIRCULAR_BUFF_LENTH, sizeof(uart_buf));
|
||
dev_ioctl(uart_hdl, UART_SET_RECV_BLOCK, 1);
|
||
dev_ioctl(uart_hdl, UART_START, 0);
|
||
|
||
os_sem_create(&assist_sem, 0);
|
||
thread_fork("assist_rx_task", 13, 512, 0, NULL, assist_rx_task, NULL);
|
||
return 0;
|
||
}
|
||
|
||
|
||
u8 is_cal_client_mac(void)
|
||
{
|
||
return ((REMOTE_MAC[0] == 0xab && REMOTE_MAC[1] == 0xab) ? 1 : 0);
|
||
}
|
||
static void wifi_enter_smp_mode(void)
|
||
{
|
||
wifi_set_smp_cfg_scan_all_channel(1);
|
||
wifi_set_smp_cfg_just_monitor_mode(0);
|
||
wifi_set_smp_cfg_timeout(100);
|
||
wifi_set_frame_cb(wbcp_rx_frame_cb, NULL);
|
||
wifi_enter_smp_cfg_mode();
|
||
}
|
||
|
||
|
||
static s8 wifi_init(void)
|
||
{
|
||
static u8 init = 0;
|
||
|
||
if (wbcp.mode == WB_SERVER_MODE) {
|
||
if (init) {
|
||
log_info("wifi already set");
|
||
return 0;
|
||
}
|
||
extern int wifi_is_on(void);
|
||
while (wifi_is_on() == 0) {
|
||
os_time_dly(1);
|
||
putchar('.');
|
||
}
|
||
wifi_set_short_retry(0);
|
||
wifi_set_long_retry(0);
|
||
}
|
||
|
||
if (wbcp.mode == WB_SERVER_MODE) {
|
||
wifi_set_frame_cb(wbcp_rx_frame_cb, NULL);
|
||
}
|
||
wifi_set_smp_cfg_scan_all_channel(0);
|
||
wifi_set_smp_cfg_just_monitor_mode(1);
|
||
wifi_set_smp_cfg_timeout(-1);
|
||
wifi_enter_smp_cfg_mode();
|
||
|
||
init = 1;
|
||
return 0;
|
||
}
|
||
|
||
|
||
static u32 wifi_send_packet(char *pkg, int len, char mcs, char phymode)
|
||
{
|
||
wifi_set_short_retry(0);
|
||
wifi_set_long_retry(0);
|
||
|
||
char i = 0;
|
||
static const struct {
|
||
char mode;
|
||
char mcs;
|
||
} mcs_mode_tab[] = {
|
||
{0, 0}, //0:CCK 1M
|
||
{0, 1}, //1:CCK 2M
|
||
{0, 2}, //2:CCK 5.5M
|
||
{1, 0}, //3:OFDM 6M
|
||
{2, 0}, //4:MCS0/7.2M
|
||
{1, 1}, //5:OFDM 9M
|
||
{0, 3}, //6:CCK 11M
|
||
{1, 2}, //7:OFDM 12M
|
||
{2, 1}, //8:MCS1/14.4M
|
||
{1, 3}, //9:OFDM 18M
|
||
{2, 2}, //10:MCS2/21.7M
|
||
{1, 4}, //11:OFDM 24M
|
||
{2, 3}, //12:MCS3/28.9M
|
||
{1, 5}, //13:OFDM 36M
|
||
{2, 4}, //14:MCS4/43.3M
|
||
{1, 6}, //15:OFDM 48M
|
||
{1, 7}, //16:OFDM 54M
|
||
{2, 5}, //17:MCS5/57.8M
|
||
{2, 6}, //18:MCS6/65.0M
|
||
{2, 7}, //19:MCS7/72.2M
|
||
};
|
||
for (i = 0; i < sizeof(mcs_mode_tab) / sizeof(mcs_mode_tab[0]); i++) {
|
||
if (mcs_mode_tab[i].mode == phymode && mcs_mode_tab[i].mcs == mcs) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
memcpy(wifi_get_payload_ptr(), pkg, len + 4);
|
||
wifi_send_data(len + 4, i);
|
||
|
||
return len;
|
||
}
|
||
|
||
|
||
static void wbcp_event_data_handler(void *priv)
|
||
{
|
||
u32 msg[16] = {0};
|
||
static u32 idx_last = 100, recv_count = 0;
|
||
u8 case_1 = 0, case_2 = 0, case_3 = 0, the_same_flag = 0;
|
||
wbcp_rx_packet_type *rx_packet = (wbcp_rx_packet_type *)priv;
|
||
|
||
if (WBCP_IDX(rx_packet) != idx_last) {
|
||
idx_last = WBCP_IDX(rx_packet);
|
||
the_same_flag = 0;
|
||
} else {
|
||
the_same_flag = 1;
|
||
/* log_info("the same idx.\n"); */
|
||
}
|
||
|
||
/* log_info("event = %d, idx = %d, idx_last = %d, the_same_flag = %d.\n", WBCP_EVENT(rx_packet), WBCP_IDX(rx_packet), idx_last, the_same_flag); */
|
||
|
||
/* if (the_same_flag == 0) { */
|
||
/* recv_count++; */
|
||
/* log_info("recv_count = %d.\n", recv_count); */
|
||
/* } */
|
||
|
||
//1.进入测试模式之前，只处理 ENTER_TEST_EVENT
|
||
//2.进入测试模式之后，处理需要ack的重复数据、ENTER_TEST_EVENT
|
||
//3.进入测试模式之后，处理非重复数据
|
||
|
||
case_1 = !wbcp.enter && WBCP_EVENT(rx_packet) == ENTER_TEST_EVENT;
|
||
case_2 = wbcp.enter && the_same_flag && (WBCP_ACK(rx_packet) || WBCP_EVENT(rx_packet) == ENTER_TEST_EVENT);
|
||
case_3 = wbcp.enter && !the_same_flag;
|
||
|
||
if (case_1 || case_2 || case_3) {
|
||
log_info("case_1 = %d, case_2 = %d, case_3 = %d.", case_1, case_2, case_3);
|
||
msg[0] = WBCP_IDX(rx_packet);
|
||
msg[1] = WBCP_ACK(rx_packet);
|
||
msg[2] = the_same_flag;
|
||
memcpy(&msg[3], &WBCP_SRC_MAC(rx_packet), MAC_ADDR_SIZE);
|
||
memcpy(&msg[5], &WBCP_EVENT_DATA(rx_packet), WBCP_EVENT_DATA_SIZE);
|
||
|
||
os_taskq_post_type("wbcp_event_data_handler_task", NEW_EVENT_MSG, ARRAY_SIZE(msg), msg);
|
||
}
|
||
}
|
||
|
||
|
||
static void wbcp_audio_data_handler(void *priv)
|
||
{
|
||
static u32 seq_last = 100;
|
||
u8 the_same_seq = 0;
|
||
s32 msg[16] = {0};
|
||
|
||
wbcp_rx_packet_type *rx_packet = (wbcp_rx_packet_type *)priv;
|
||
|
||
if (WBCP_SEQ(rx_packet) != seq_last) {
|
||
seq_last = WBCP_SEQ(rx_packet);
|
||
the_same_seq = 0;
|
||
} else {
|
||
the_same_seq = 1;
|
||
}
|
||
|
||
msg[0] = WBCP_IDX(rx_packet);
|
||
msg[1] = WBCP_ACK(rx_packet);
|
||
msg[2] = WBCP_SEQ(rx_packet);
|
||
memcpy(&msg[3], &WBCP_SRC_MAC(rx_packet), MAC_ADDR_SIZE);
|
||
os_taskq_post_type("wbcp_event_data_handler_task", RECV_AUDIO_MSG, ARRAY_SIZE(msg), msg);
|
||
if (!the_same_seq) {
|
||
wbcp_audio_data_user_handler(&WBCP_AUDIO_DATA(rx_packet));
|
||
}
|
||
}
|
||
|
||
|
||
static void wbcp_null_data_handler(void *rxwi)
|
||
{
|
||
s8 pwr = 0, evm = 0;
|
||
s32 freq = 0, freq_temp = 0;
|
||
PRXWI_STRUC pRxWI = (PRXWI_STRUC *)rxwi;
|
||
|
||
if (wbcp.enter && stat_prop.start) {
|
||
if ((pRxWI->PHYMODE == conn_params.test_phymode) && (pRxWI->MCS == conn_params.test_mcs)) {
|
||
putchar('R');
|
||
pwr = (pRxWI->RSSI0);
|
||
evm = (pRxWI->SNR1);
|
||
freq_temp = (bbp_rd(62) << 8) | bbp_rd(61);
|
||
freq = (freq_temp * 20 * 1000000) / 16 / 2 / 512 / 1000;
|
||
|
||
stat_prop.num++;
|
||
stat_prop.pwr_sum += pwr;
|
||
stat_prop.evm_sum += evm;
|
||
stat_prop.freq_sum += freq;
|
||
stat_prop.stat_res.pcnt = stat_prop.num;
|
||
stat_prop.stat_res.pwr = stat_prop.pwr_sum / stat_prop.num;
|
||
stat_prop.stat_res.evm = stat_prop.evm_sum / stat_prop.num;
|
||
stat_prop.stat_res.freq = stat_prop.freq_sum / stat_prop.num;
|
||
|
||
/* log_info("num = %d, pwr = %d, evm = %d, freq = %d.\n", stat_prop.num, pwr, evm, freq); */
|
||
if (stat_prop.num > stat_prop.count && stat_prop.count) {
|
||
log_info("result : pcnt = %d, pwr = %d, evm = %d, freq = %d.\n", stat_prop.stat_res.pcnt, stat_prop.stat_res.pwr, stat_prop.stat_res.evm, stat_prop.stat_res.freq);
|
||
os_sem_post(&stat_prop.stat_sem);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
static void wbcp_rx_packet_handler(void *rxwi, void *priv)
|
||
{
|
||
static u32 idx_last = 100;
|
||
u8 the_same_flag = 0;
|
||
wbcp_rx_packet_type *rx_packet = (wbcp_rx_packet_type *)priv;
|
||
wbcp_tx_packet_type *tx_packet = &wbcp.tx_packet;
|
||
|
||
if (wbcp.assist_flag && WBCP_TYPE(rx_packet) != NULL_DATA_TYPE) {
|
||
return;
|
||
}
|
||
|
||
switch (WBCP_TYPE(rx_packet)) {
|
||
case EVENT_DATA_TYPE :
|
||
/* log_info("EVENT_DATA_TYPE.\n"); */
|
||
wbcp_event_data_handler(rx_packet);
|
||
break;
|
||
|
||
case RESP_DATA_TYPE:
|
||
if (WBCP_IDX(rx_packet) != idx_last) {
|
||
idx_last = WBCP_IDX(rx_packet);
|
||
the_same_flag = 0;
|
||
} else {
|
||
the_same_flag = 1;
|
||
}
|
||
if (WBCP_IDX(rx_packet) == WBCP_IDX(tx_packet) && !the_same_flag) {
|
||
log_info("RESP_DATA_TYPE : idx = %d, tx_idx = %d.\n", WBCP_IDX(rx_packet), WBCP_IDX(tx_packet));
|
||
os_sem_post(&wbcp.tx_sem);
|
||
}
|
||
break;
|
||
|
||
case AUDIO_DATA_TYPE:
|
||
log_info("AUDIO_DATA_TYPE.\n");
|
||
if (!wbcp_audio_data_user_handler) {
|
||
log_info("wbcp_audio_data_user_handler no regist.");
|
||
break;
|
||
}
|
||
wbcp_audio_data_handler(rx_packet);
|
||
break;
|
||
|
||
case NULL_DATA_TYPE:
|
||
wbcp_null_data_handler(rxwi);
|
||
break;
|
||
|
||
default :
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
void wbcp_rx_frame_cb(void *rxwi, void *header, void *data, u32 len, void *priv)
|
||
{
|
||
wbcp_rx_packet_type *rx_packet = (wbcp_rx_packet_type *)data;
|
||
u8 *str = NULL;
|
||
PRXWI_STRUC pRxWI = (PRXWI_STRUC *)rxwi;
|
||
s8 rssi0 = pRxWI->RSSI0;
|
||
struct wifi_mode_info mode_info = {0};
|
||
|
||
if (wbcp.shield) {
|
||
return;
|
||
}
|
||
|
||
switch (wbcp.mode) {
|
||
case WB_SERVER_MODE:
|
||
if (wbcp.build_conn && memcmp(WBCP_DEST_MAC(rx_packet), LOCAL_MAC, MAC_ADDR_SIZE) == 0) {
|
||
if (!wbcp.enter || (wbcp.enter && (memcmp(WBCP_SRC_MAC(rx_packet), REMOTE_MAC, MAC_ADDR_SIZE) == 0))) {
|
||
if ((WBCP_CRC(rx_packet) == WBCP_PACKET_CRC_CAL(rx_packet)) && (WBCP_VERSION(rx_packet) == WBCP_VERSION_ID)) {
|
||
wbcp_rx_packet_handler(rxwi, rx_packet);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case WB_CLIENT_MODE:
|
||
wifi_get_mode_cur_info(&mode_info);
|
||
if (mode_info.mode != SMP_CFG_MODE) {
|
||
return;
|
||
}
|
||
|
||
if (!wbcp.respond_flag) {
|
||
if (strcmp(&WBCP_CONN_SER(rx_packet), WBCP_CONN_SERIAL) == 0) {
|
||
if (WBCP_CRC(rx_packet) == WBCP_CONN_PARAMS_CRC_CAL(rx_packet)) {
|
||
memcpy(REMOTE_MAC, &WBCP_SRC_MAC(rx_packet), MAC_ADDR_SIZE);
|
||
memcpy(&conn_params, &WBCP_CONN_PARAMS(rx_packet), WBCP_CONN_PARAMS_SIZE);
|
||
conn_params_show(&conn_params);
|
||
if (rssi0 < conn_params.rssi_thr) {
|
||
log_err("rssi too low, rssi(%d) < rssi_thr(%d)", rssi0, conn_params.rssi_thr);
|
||
return;
|
||
}
|
||
|
||
log_info("REMOTE_MAC : %02X-%02X-%02X-%02X-%02X-%02X.\n", REMOTE_MAC[0], REMOTE_MAC[1], REMOTE_MAC[2], \
|
||
REMOTE_MAC[3], REMOTE_MAC[4], REMOTE_MAC[5]);
|
||
int wifibox_client_init(void);
|
||
wifibox_client_init();
|
||
wbcp.respond_flag = 1;
|
||
os_sem_post(&wbcp.respond_sem);
|
||
}
|
||
}
|
||
} else {
|
||
if (memcmp(WBCP_DEST_MAC(rx_packet), LOCAL_MAC, MAC_ADDR_SIZE) == 0) {
|
||
if (memcmp(WBCP_SRC_MAC(rx_packet), REMOTE_MAC, MAC_ADDR_SIZE) == 0) {
|
||
if ((WBCP_CRC(rx_packet) == WBCP_PACKET_CRC_CAL(rx_packet)) && \
|
||
(WBCP_VERSION(rx_packet) == WBCP_VERSION_ID)) {
|
||
wbcp_rx_packet_handler(rxwi, rx_packet);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
static s32 wbcp_update_event_to_user_handler(u8 type, s32 msg_size, s32 *msg)
|
||
{
|
||
s32 ret = 0;
|
||
u8 retry_cnt = 0;
|
||
|
||
do {
|
||
ret = os_taskq_post_type(user_handler_task, type, msg_size, msg);
|
||
if (ret != OS_NO_ERR) {
|
||
retry_cnt++;
|
||
os_time_dly(1);
|
||
}
|
||
} while (ret != OS_NO_ERR && retry_cnt < 10);
|
||
|
||
if (ret != OS_NO_ERR) {
|
||
log_err("wbcp_update_event_to_user_handler err = %d.", ret);
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
static void wbcp_event_data_handler_task(void *priv)
|
||
{
|
||
int msg[32] = {0};
|
||
u32 idx = 0;
|
||
u8 the_same_flag = 0, ack_flag = 0, seq = 0;
|
||
u8 *src_mac = NULL;
|
||
event_data_type *event_data = NULL;
|
||
event_data_type new_event = {0};
|
||
static wbcp_payload_type ack_payload = {0};
|
||
|
||
for (;;) {
|
||
if (os_taskq_pend(NULL, msg, ARRAY_SIZE(msg)) != OS_TASKQ) {
|
||
continue;
|
||
}
|
||
|
||
if (msg[0] == NEW_EVENT_MSG) {
|
||
idx = msg[1];
|
||
ack_flag = msg[2];
|
||
the_same_flag = msg[3];
|
||
src_mac = (u8 *)&msg[4];
|
||
event_data = (event_data_type *)&msg[6];
|
||
log_info("ack : event %d", event_data->event);
|
||
} else if (msg[0] == RECV_AUDIO_MSG) {
|
||
idx = msg[1];
|
||
ack_flag = msg[2];
|
||
seq = msg[3];
|
||
src_mac = (u8 *)&msg[4];
|
||
log_info("ack : seq %d", seq);
|
||
} else {
|
||
continue;
|
||
}
|
||
|
||
if (ack_flag) {
|
||
ack_payload.version = WBCP_VERSION_ID;
|
||
ack_payload.type = RESP_DATA_TYPE;
|
||
ack_payload.ack = 0;
|
||
ack_payload.seq = 0;
|
||
ack_payload.idx = idx;
|
||
wbcp_send_ack(&ack_payload, src_mac, conn_params.conn_mcs, conn_params.conn_phymode);
|
||
}
|
||
|
||
if (msg[0] == RECV_AUDIO_MSG) {
|
||
continue;
|
||
}
|
||
|
||
/* log_info("handler task : event = %d, idx = %d, the_same_flag = %d.\n", event_data->event, idx, the_same_flag); */
|
||
switch (wbcp.mode) {
|
||
case WB_SERVER_MODE:
|
||
if (!wbcp.enter) {
|
||
if (event_data->event == ENTER_TEST_EVENT && !wbcp.respond_flag) {
|
||
wbcp_update_seach_status(STOP_SEARCH_MSG, 0);
|
||
wbcp.respond_flag = 1;
|
||
new_event.event = ENTER_TEST_EVENT;
|
||
memcpy(REMOTE_MAC, src_mac, MAC_ADDR_SIZE);
|
||
log_info("REMOTE_MAC : %02X-%02X-%02X-%02X-%02X-%02X.\n", REMOTE_MAC[0], REMOTE_MAC[1], REMOTE_MAC[2], \
|
||
REMOTE_MAC[3], REMOTE_MAC[4], REMOTE_MAC[5]);
|
||
|
||
wifi_set_channel(conn_params.channel);
|
||
log_info("WB_CH[%d]", conn_params.channel);
|
||
if (wbcp_send_event_data(&new_event, REMOTE_MAC, 1) == 0) {
|
||
wbcp.enter = 1;
|
||
msg[0] = (s32)&REMOTE_MAC[0];
|
||
if (is_cal_client_mac()) {
|
||
memcpy(&msg[1], &event_data->params.cal_params, sizeof(calibrate_params_type));
|
||
wbcp_update_event_to_user_handler(ENTER_TEST_SUCC_MSG, (sizeof(calibrate_params_type) / sizeof(s32)) + 1, msg);
|
||
} else {
|
||
wbcp_update_event_to_user_handler(ENTER_TEST_SUCC_MSG, 1, msg);
|
||
}
|
||
} else {
|
||
wbcp_update_event_to_user_handler(ENTER_TEST_FAIL_MSG, 1, msg);
|
||
}
|
||
}
|
||
} else {
|
||
if (!the_same_flag && event_data->event != ENTER_TEST_EVENT) {
|
||
wbcp_update_event_to_user_handler(NEW_EVENT_MSG, WBCP_EVENT_DATA_SIZE / sizeof(s32), (s32 *)event_data);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case WB_CLIENT_MODE:
|
||
if (!wbcp.enter) {
|
||
if (event_data->event == ENTER_TEST_EVENT) {
|
||
wbcp.enter = 1;
|
||
msg[0] = (s32)&REMOTE_MAC[0];
|
||
msg[1] = (s32)&conn_params;
|
||
wbcp_update_event_to_user_handler(ENTER_TEST_SUCC_MSG, 2, msg);
|
||
}
|
||
} else {
|
||
if (!the_same_flag && event_data->event != ENTER_TEST_EVENT) {
|
||
wbcp_update_event_to_user_handler(NEW_EVENT_MSG, WBCP_EVENT_DATA_SIZE / sizeof(s32), (s32 *)event_data);
|
||
}
|
||
}
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
static u32 wbcp_send_packet_with_noack(wbcp_payload_type *payload, u8 *dest_mac, u8 mcs, u8 phymode)
|
||
{
|
||
memcpy(wbcp.tx_packet.dest_mac, dest_mac, MAC_ADDR_SIZE);
|
||
memcpy(&wbcp.tx_packet.payload, payload, WBCP_PAYLOAD_SIZE);
|
||
wbcp.tx_packet.crc = CRC16(payload, WBCP_PAYLOAD_SIZE);
|
||
|
||
return wifi_send_packet(&wbcp.tx_packet, WBCP_TX_PACKET_SIZE, mcs, phymode);
|
||
}
|
||
|
||
|
||
static void wbcp_send_packet_with_ack_task(void *priv)
|
||
{
|
||
s32 msg[8] = {0};
|
||
wbcp_payload_type *payload = NULL;
|
||
u8 *dest_mac = NULL;
|
||
u8 mcs = 0, phymode = 0;
|
||
u8 retry_cnt = 0;
|
||
|
||
for (;;) {
|
||
if (os_taskq_pend(NULL, msg, ARRAY_SIZE(msg)) != OS_TASKQ) {
|
||
continue;
|
||
}
|
||
|
||
if (msg[0] != SEND_PACKET_MSG) {
|
||
continue;
|
||
}
|
||
|
||
mcs = msg[1];
|
||
phymode = msg[2];
|
||
retry_cnt = 0;
|
||
|
||
while (wbcp.send_withack_flag) {
|
||
wifi_send_packet(&wbcp.tx_packet, WBCP_TX_PACKET_SIZE, mcs, phymode);
|
||
log_info("retry_cnt = %d.", ++retry_cnt);
|
||
os_time_dly(WBCP_SEND_WITHACK_RETRY_PERIOD);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
static u32 wbcp_send_packet_with_ack(wbcp_payload_type *payload, u8 *dest_mac, u8 mcs, u8 phymode)
|
||
{
|
||
u32 ret = 0;
|
||
s32 msg[4] = {0};
|
||
|
||
msg[0] = mcs;
|
||
msg[1] = phymode;
|
||
|
||
memcpy(wbcp.tx_packet.dest_mac, dest_mac, MAC_ADDR_SIZE);
|
||
memcpy(&wbcp.tx_packet.payload, payload, WBCP_PAYLOAD_SIZE);
|
||
wbcp.tx_packet.crc = CRC16(payload, WBCP_PAYLOAD_SIZE);
|
||
|
||
if (os_taskq_post_type("wbcp_send_packet_with_ack_task", SEND_PACKET_MSG, ARRAY_SIZE(msg), msg) != OS_NO_ERR) {
|
||
return 0;
|
||
}
|
||
|
||
wbcp.send_withack_flag = 1;
|
||
os_sem_set(&wbcp.tx_sem, 0);
|
||
ret = os_sem_pend(&wbcp.tx_sem, WBCP_WAIT_ACK_TIMEOUT);
|
||
wbcp.send_withack_flag = 0;
|
||
|
||
ret = (ret == OS_NO_ERR) ? WBCP_TX_PACKET_SIZE : 0;
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
static u32 wbcp_send_packet(wbcp_payload_type *payload, u8 *dest_mac, u8 mcs, u8 phymode, u8 ack)
|
||
{
|
||
static u32 global_idx = 0;
|
||
u32 ret = 0;
|
||
|
||
global_idx++;
|
||
payload->idx = global_idx;
|
||
/* log_info("global_idx = %d.", global_idx); */
|
||
|
||
if (ack) {
|
||
ret = wbcp_send_packet_with_ack(payload, dest_mac, mcs, phymode);
|
||
} else {
|
||
ret = wbcp_send_packet_with_noack(payload, dest_mac, mcs, phymode);
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
static void wbcp_send_ack(wbcp_payload_type *payload, u8 *dest_mac, u8 mcs, u8 phymode)
|
||
{
|
||
/* os_mutex_pend(&wbcp.ack_mutex, 0); */
|
||
|
||
memcpy(wbcp.ack_packet.dest_mac, dest_mac, MAC_ADDR_SIZE);
|
||
memcpy(&wbcp.ack_packet.payload, payload, WBCP_PAYLOAD_SIZE);
|
||
wbcp.ack_packet.crc = CRC16(payload, WBCP_PAYLOAD_SIZE);
|
||
wifi_send_packet(&wbcp.ack_packet, WBCP_TX_PACKET_SIZE, mcs, phymode);
|
||
|
||
/* os_mutex_post(&wbcp.ack_mutex); */
|
||
}
|
||
|
||
|
||
static s8 wbcp_send_event_data(event_data_type *event_data, u8 *dest_mac, u8 ack)
|
||
{
|
||
u32 len = 0;
|
||
wbcp_payload_type payload = {0};
|
||
|
||
if (wbcp.assist_flag) {
|
||
len = assist_tx_data(event_data);
|
||
return ((len == sizeof(event_data_type)) ? 0 : -1);
|
||
}
|
||
|
||
LOCK_TX_PACKET();
|
||
|
||
payload.version = WBCP_VERSION_ID;
|
||
payload.type = EVENT_DATA_TYPE;
|
||
payload.ack = ack;
|
||
payload.seq = 0;
|
||
payload.idx = 0;
|
||
memcpy(&payload.wbcp_data.event_data, event_data, WBCP_EVENT_DATA_SIZE);
|
||
len = wbcp_send_packet(&payload, dest_mac, conn_params.conn_mcs, conn_params.conn_phymode, ack);
|
||
|
||
UNLOCK_TX_PACKET();
|
||
|
||
return ((len == WBCP_TX_PACKET_SIZE) ? 0 : -1);
|
||
}
|
||
|
||
|
||
static s8 wbcp_send_audio_data(audio_data_type *audio_data, u8 *dest_mac, u8 seq)
|
||
{
|
||
u32 len = 0;
|
||
wbcp_payload_type payload = {0};
|
||
|
||
LOCK_TX_PACKET();
|
||
|
||
payload.version = WBCP_VERSION_ID;
|
||
payload.type = AUDIO_DATA_TYPE;
|
||
payload.ack = 1;
|
||
payload.seq = seq;
|
||
payload.idx = 0;
|
||
memcpy(&payload.wbcp_data.audio_data, audio_data, WBCP_AUDIO_DATA_SIZE);
|
||
len = wbcp_send_packet(&payload, dest_mac, conn_params.conn_mcs, conn_params.conn_phymode, 1);
|
||
|
||
UNLOCK_TX_PACKET();
|
||
|
||
return ((len == WBCP_TX_PACKET_SIZE) ? 0 : -1);
|
||
}
|
||
|
||
|
||
static s8 wbcp_send_null_data(u8 *dest_mac)
|
||
{
|
||
u32 len = 0;
|
||
wbcp_payload_type payload = {0};
|
||
|
||
LOCK_TX_PACKET();
|
||
|
||
payload.version = WBCP_VERSION_ID;
|
||
payload.type = NULL_DATA_TYPE;
|
||
payload.ack = 0;
|
||
payload.seq = 0;
|
||
payload.idx = 0;
|
||
|
||
len = wbcp_send_packet(&payload, dest_mac, conn_params.test_mcs, conn_params.test_phymode, 0);
|
||
|
||
UNLOCK_TX_PACKET();
|
||
|
||
return ((len == WBCP_TX_PACKET_SIZE) ? 0 : -1);
|
||
}
|
||
|
||
|
||
static void wbcp_start_send_test_data_task(void *priv)
|
||
{
|
||
s32 msg[16];
|
||
u32 num = 0;
|
||
u8 *dest_mac = NULL;
|
||
u32 count = 0, periodic = 0;
|
||
|
||
for (;;) {
|
||
if (os_taskq_pend(NULL, msg, ARRAY_SIZE(msg)) != OS_TASKQ) {
|
||
continue;
|
||
}
|
||
|
||
if (msg[0] != START_SEND_MSG) {
|
||
continue;
|
||
}
|
||
|
||
dest_mac = (u8 *)msg[1];
|
||
periodic = msg[2];
|
||
count = msg[3];
|
||
num = 0;
|
||
|
||
while (stat_prop.send_test_flag) {
|
||
wbcp_send_null_data(dest_mac);
|
||
putchar('T');
|
||
if (++num > count && count) {
|
||
os_sem_post(&stat_prop.test_sem);
|
||
stat_prop.send_test_flag = 0;
|
||
}
|
||
os_time_dly(periodic);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
static s32 wbcp_start_send_test_data(u8 *dest_mac, u32 periodic, u32 count)
|
||
{
|
||
s32 msg[8] = {0};
|
||
s32 ret = 0;
|
||
|
||
msg[0] = (s32)dest_mac;
|
||
msg[1] = periodic;
|
||
msg[2] = count;
|
||
|
||
stat_prop.send_test_flag = 1;
|
||
ret = os_taskq_post_type("wbcp_start_send_test_data_task", START_SEND_MSG, ARRAY_SIZE(msg), msg);
|
||
|
||
if (ret == OS_NO_ERR) {
|
||
if (count) {
|
||
os_sem_set(&stat_prop.test_sem, 0);
|
||
os_sem_pend(&stat_prop.test_sem, 0);
|
||
return 0;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
|
||
static void wbcp_stop_send_test_data(void)
|
||
{
|
||
stat_prop.send_test_flag = 0;
|
||
}
|
||
|
||
|
||
static void wbcp_regist_user_handler(void *priv)
|
||
{
|
||
strcpy(user_handler_task, priv);
|
||
}
|
||
|
||
|
||
static void wbcp_regist_audio_data_user_handler(void *priv)
|
||
{
|
||
wbcp_audio_data_user_handler = priv;
|
||
}
|
||
|
||
|
||
static void wbcp_launch_conn_req_task(void *priv)
|
||
{
|
||
s32 msg[4] = {0};
|
||
u8 ch = 0;
|
||
u8 flag = 0;
|
||
|
||
/* LOCK_TX_PACKET(); */
|
||
/* memcpy(&wbcp.tx_packet.conn_params, &conn_params, WBCP_CONN_PARAMS_SIZE); */
|
||
/* wbcp.tx_packet.crc = CRC16(&wbcp.tx_packet.conn_params, WBCP_CONN_PARAMS_SIZE); */
|
||
|
||
/* printf("TEST_TEST, START_SEARCH_MSG\n"); */
|
||
/* msg[0] = conn_params.channel; */
|
||
/* wbcp_update_event_to_user_handler(START_SEARCH_MSG, 1, &msg[0]); */
|
||
|
||
for (;;) {
|
||
if (os_taskq_pend(NULL, msg, ARRAY_SIZE(msg)) != OS_TASKQ) {
|
||
continue;
|
||
}
|
||
|
||
if (msg[0] != UPDATE_CH_MSG && msg[0] != START_SEARCH_MSG && msg[0] != STOP_SEARCH_MSG) {
|
||
continue;
|
||
}
|
||
|
||
if (msg[0] == STOP_SEARCH_MSG) {
|
||
log_info("TEST_TEST, STOP_SEARCH_MSG");
|
||
flag = 0;
|
||
/* goto _exit_serch_; */
|
||
} else if (msg[0] == START_SEARCH_MSG) {
|
||
flag = 1;
|
||
}
|
||
|
||
if (flag) {
|
||
ch = msg[1];
|
||
wifi_set_channel(ch);
|
||
log_info("WB_CH[%d]", ch);
|
||
|
||
for (u8 j = 0; j < 5; j++) {
|
||
wifi_send_packet(&wbcp.tx_packet, WBCP_TX_PACKET_SIZE, conn_params.conn_mcs, conn_params.conn_phymode);
|
||
os_time_dly(1);
|
||
}
|
||
|
||
msg[0] = ch;
|
||
wbcp_update_event_to_user_handler(UPDATE_CH_MSG, 1, &msg[0]);
|
||
}
|
||
}
|
||
|
||
/* _exit_serch_: */
|
||
/* UNLOCK_TX_PACKET(); */
|
||
}
|
||
|
||
|
||
static s32 wbcp_update_seach_status(u8 type, u8 ch)
|
||
{
|
||
s32 ret = 0, msg = 0;
|
||
u8 retry_cnt = 0;
|
||
|
||
msg = ch;
|
||
|
||
do {
|
||
ret = os_taskq_post_type("wbcp_launch_conn_req_task", type, 1, &msg);
|
||
if (ret != OS_NO_ERR) {
|
||
retry_cnt++;
|
||
os_time_dly(1);
|
||
}
|
||
} while (ret != OS_NO_ERR && retry_cnt < 10);
|
||
|
||
if (ret != OS_NO_ERR) {
|
||
log_err("wbcp_update_seach_status err = %d.", ret);
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
static void wbcp_respond_conn_req_task(void)
|
||
{
|
||
event_data_type event_data = {0};
|
||
event_data.event = ENTER_TEST_EVENT;
|
||
s8 respond_cnt = 0;
|
||
s32 msg[2];
|
||
|
||
#ifdef WBCP_CAL_DUT
|
||
memcpy(&event_data.params.cal_params, get_wifibox_cal_params(), sizeof(calibrate_params_type));
|
||
#endif
|
||
|
||
_next_:
|
||
respond_cnt = 0;
|
||
for (;;) {
|
||
os_sem_set(&wbcp.respond_sem, 0);
|
||
os_sem_pend(&wbcp.respond_sem, 0);
|
||
|
||
if (wbcp.assist_flag) {
|
||
wbcp.enter = 1;
|
||
wbcp.respond_flag = 1;
|
||
msg[0] = (s32)&REMOTE_MAC[0];
|
||
msg[1] = (s32)&conn_params;
|
||
wbcp_update_event_to_user_handler(ENTER_TEST_SUCC_MSG, 2, msg);
|
||
|
||
wifi_init();
|
||
wifi_set_channel(conn_params.channel);
|
||
log_info("WB_CH[%d]", conn_params.channel);
|
||
|
||
event_data.event = ENTER_TEST_EVENT;
|
||
memcpy(event_data.params.conn_params.mac, LOCAL_MAC, MAC_ADDR_SIZE);
|
||
if (!assist_tx_data(&event_data)) {
|
||
msg[0] = conn_params.dut_reset_flag;
|
||
wbcp_update_event_to_user_handler(ENTER_TEST_FAIL_MSG, 1, &msg[0]);
|
||
}
|
||
goto _next_;
|
||
}
|
||
|
||
wifi_init();
|
||
wifi_set_channel(conn_params.channel);
|
||
log_info("WB_CH[%d]", conn_params.channel);
|
||
|
||
for (;;) {
|
||
if (++respond_cnt < MAX_RESPOND_CNT) {
|
||
wbcp_send_event_data(&event_data, REMOTE_MAC, 0);
|
||
log_info("respond_cnt = %d.", respond_cnt);
|
||
putchar('>');
|
||
} else {
|
||
msg[0] = conn_params.dut_reset_flag;
|
||
wbcp_update_event_to_user_handler(ENTER_TEST_FAIL_MSG, 1, &msg[0]);
|
||
goto _next_;
|
||
}
|
||
|
||
if (wbcp.enter) {
|
||
goto _next_;
|
||
/* return; */
|
||
}
|
||
os_time_dly(5);
|
||
}
|
||
os_time_dly(1);
|
||
}
|
||
}
|
||
|
||
|
||
static s8 wbcp_build_conn(void *params)
|
||
{
|
||
s32 msg = 0;
|
||
event_data_type event_data = {0};
|
||
|
||
if (wbcp.enter) {
|
||
return -1;
|
||
}
|
||
wbcp.exit = 0;
|
||
wbcp.build_conn = 1;
|
||
|
||
memcpy(&conn_params, params, WBCP_CONN_PARAMS_SIZE);
|
||
conn_params_show(&conn_params);
|
||
|
||
wifi_init();
|
||
|
||
if (wbcp.assist_flag) {
|
||
event_data.event = ENTER_TEST_EVENT;
|
||
memcpy(&event_data.params.conn_params, params, WBCP_CONN_PARAMS_SIZE);
|
||
memcpy(event_data.params.conn_params.mac, LOCAL_MAC, MAC_ADDR_SIZE);
|
||
if (!assist_tx_data(&event_data)) {
|
||
wbcp_update_event_to_user_handler(ENTER_TEST_FAIL_MSG, 1, &msg);
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
LOCK_TX_PACKET();
|
||
memcpy(&wbcp.tx_packet.conn_params, &conn_params, WBCP_CONN_PARAMS_SIZE);
|
||
wbcp.tx_packet.crc = CRC16(&wbcp.tx_packet.conn_params, WBCP_CONN_PARAMS_SIZE);
|
||
UNLOCK_TX_PACKET();
|
||
|
||
msg = conn_params.channel;
|
||
wbcp_update_event_to_user_handler(START_SEARCH_MSG, 1, &msg);
|
||
wbcp_update_seach_status(START_SEARCH_MSG, msg);
|
||
|
||
/* if (thread_fork("wbcp_launch_conn_req_task", 12, 512, 512, NULL, wbcp_launch_conn_req_task, NULL) != OS_NO_ERR) { */
|
||
/* log_err("thread fork fail : %s, %d.\n", __FILE__, __LINE__); */
|
||
/* return -1; */
|
||
/* } */
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
static void wbcp_break_conn(void)
|
||
{
|
||
wbcp.build_conn = 0;
|
||
wbcp.enter = 0;
|
||
wbcp.exit = 1;
|
||
wbcp.respond_flag = 0;
|
||
memset(REMOTE_MAC, 0, MAC_ADDR_SIZE);
|
||
|
||
if (wbcp.mode == WB_SERVER_MODE && !wbcp.assist_flag) {
|
||
wbcp_update_seach_status(STOP_SEARCH_MSG, 0);
|
||
} else if (wbcp.mode == WB_CLIENT_MODE) {
|
||
wifi_enter_smp_mode();
|
||
}
|
||
}
|
||
|
||
|
||
static void wbcp_rx_shield(void)
|
||
{
|
||
wbcp.shield = 1;
|
||
}
|
||
|
||
|
||
static void *wbcp_start_stat_prop(u32 count, u32 timeout)
|
||
{
|
||
s32 ret = 0;
|
||
|
||
stat_prop.count = count;
|
||
stat_prop.num = 0;
|
||
stat_prop.pwr_sum = 0;
|
||
stat_prop.evm_sum = 0;
|
||
stat_prop.freq_sum = 0;
|
||
memset(&stat_prop.stat_res, 0, sizeof(stat_res_type));
|
||
stat_prop.start = 1;
|
||
|
||
if (stat_prop.count) {
|
||
os_sem_set(&stat_prop.stat_sem, 0);
|
||
if (os_sem_pend(&stat_prop.stat_sem, timeout) == OS_NO_ERR) {
|
||
stat_prop.start = 0;
|
||
return &stat_prop.stat_res;
|
||
}
|
||
}
|
||
|
||
return NULL;
|
||
}
|
||
|
||
|
||
static void *wbcp_stop_stat_prop(void)
|
||
{
|
||
stat_prop.start = 0;
|
||
return &stat_prop.stat_res;
|
||
}
|
||
|
||
|
||
static s8 wbcp_init(u8 mode, u8 is_assist)
|
||
{
|
||
u8 none_data_1[30] = {
|
||
0x14, 0x06, 0x00, 0x04, 0xB0, 0x00, 0x04, 0x80, 0x35, 0x01, 0x02, 0x46, 0x00, 0x00, 0x00, 0x00,
|
||
0x00, 0x00, 0x00, 0x00, 0x88, 0x81, 0x00, 0x00, 0x44, 0x66, 0x66, 0x66, 0x66, 0x66
|
||
};
|
||
|
||
u8 none_data_2[46] = {
|
||
0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
0x00, 0x80, 0x00, 0x00, 0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x45, 0x00, 0x05, 0xDC,
|
||
0x00, 0x0B, 0x20, 0x00, 0xFF, 0x11, 0xD5, 0xC8, 0xC0, 0xA8, 0x1F, 0xD3, 0xff, 0xff, 0xff, 0xff,
|
||
0x13, 0x89, 0xA4, 0xFF, 0x20, 0x08, 0x67, 0x37
|
||
};
|
||
|
||
u8 none_data_3[] = {
|
||
0xc6, 0x00, 0x00, 0x04, 0xB0, 0x00, 0x04, 0x80, 0x35, 0x01, 0xB6, 0x40, 0x00, 0x00, 0x00, 0x00,
|
||
0x00, 0x00, 0x00, 0x00, 0x88, 0x02, 0x00, 0x00, 0x0C, 0x62, 0x0E, 0xD4, 0x46, 0x3E, 0x24, 0x8B,
|
||
0xA7, 0x24, 0x63, 0x17, 0x24, 0x8B, 0xA7, 0x24, 0x63, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||
0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x45, 0x00, 0x05, 0xDB, 0x00, 0x02, 0x00, 0x00,
|
||
0xFF, 0x01, 0x32, 0xCC, 0xC0, 0xA8, 0x01, 0x01, 0xC0, 0xA8, 0x01, 0x02, 0x08, 0x00, 0x53, 0x75,
|
||
0xAF, 0xAF, 0x70, 0x37
|
||
};
|
||
|
||
wbcp.mode = mode;
|
||
wifi_get_mac(LOCAL_MAC);
|
||
log_info("LOCAL_MAC : %02X-%02X-%02X-%02X-%02X-%02X.\n", LOCAL_MAC[0], LOCAL_MAC[1], LOCAL_MAC[2], LOCAL_MAC[3], LOCAL_MAC[4], LOCAL_MAC[5]);
|
||
|
||
#ifdef WBCP_CAL_DUT
|
||
if (wbcp.mode == WB_CLIENT_MODE) {
|
||
LOCAL_MAC[0] = 0xab;
|
||
LOCAL_MAC[1] = 0xab;
|
||
}
|
||
#endif
|
||
|
||
/* memcpy(wbcp.tx_packet.none_data_1, none_data_1, sizeof(none_data_1)); */
|
||
/* memcpy(wbcp.tx_packet.none_data_2, none_data_2, sizeof(none_data_2)); */
|
||
u16 *pkg_len = &none_data_3[0];
|
||
pkg_len = sizeof(wbcp_tx_packet_type) + 4 - 8;
|
||
memcpy(&wbcp.tx_packet, none_data_3, sizeof(none_data_3));
|
||
memcpy(wbcp.tx_packet.src_mac, LOCAL_MAC, MAC_ADDR_SIZE);
|
||
|
||
memcpy(&wbcp.ack_packet, &wbcp.tx_packet, WBCP_TX_PACKET_SIZE);
|
||
|
||
os_mutex_create(&wbcp.tx_mutex);
|
||
os_mutex_create(&wbcp.ack_mutex);
|
||
os_sem_create(&wbcp.tx_sem, 0);
|
||
os_sem_create(&wbcp.respond_sem, 0);
|
||
os_sem_create(&stat_prop.stat_sem, 0);
|
||
os_sem_create(&stat_prop.test_sem, 0);
|
||
|
||
if (thread_fork("wbcp_event_data_handler_task", 15, 1024, 2 * 1024, NULL, wbcp_event_data_handler_task, NULL) != OS_NO_ERR) {
|
||
log_err("thread fork fail : %s, %d.\n", __FILE__, __LINE__);
|
||
return -1;
|
||
}
|
||
|
||
if (thread_fork("wbcp_send_packet_with_ack_task", 12, 1024, 512, NULL, wbcp_send_packet_with_ack_task, NULL) != OS_NO_ERR) {
|
||
log_err("thread fork fail : %s, %d.\n", __FILE__, __LINE__);
|
||
return -1;
|
||
}
|
||
|
||
if (thread_fork("wbcp_start_send_test_data_task", 12, 1024, 512, NULL, wbcp_start_send_test_data_task, NULL) != OS_NO_ERR) {
|
||
log_err("thread fork fail : %s, %d.\n", __FILE__, __LINE__);
|
||
return -1;
|
||
}
|
||
|
||
if (wbcp.mode == WB_SERVER_MODE) {
|
||
if (thread_fork("wbcp_launch_conn_req_task", 12, 512, 512, NULL, wbcp_launch_conn_req_task, NULL) != OS_NO_ERR) {
|
||
log_err("thread fork fail : %s, %d.\n", __FILE__, __LINE__);
|
||
return -1;
|
||
}
|
||
} else if (wbcp.mode == WB_CLIENT_MODE) {
|
||
if (thread_fork("wbcp_respond_conn_req_task", 12, 2 * 1024, 0, NULL, wbcp_respond_conn_req_task, NULL) != OS_NO_ERR) {
|
||
log_err("thread fork fail : %s, %d.\n", __FILE__, __LINE__);
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
wbcp.assist_flag = is_assist;
|
||
if (wbcp.assist_flag) {
|
||
assist_dev_init();
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
static const wbcp_operations_interface_type wbcp_ops = {
|
||
.init = wbcp_init,
|
||
.update_seach_status = wbcp_update_seach_status,
|
||
.build_conn = wbcp_build_conn,
|
||
.break_conn = wbcp_break_conn,
|
||
.rx_shield = wbcp_rx_shield,
|
||
.send_event_data = wbcp_send_event_data,
|
||
.send_audio_data = wbcp_send_audio_data,
|
||
.start_send_test_data = wbcp_start_send_test_data,
|
||
.stop_send_test_data = wbcp_stop_send_test_data,
|
||
.regist_usr_handler = wbcp_regist_user_handler,
|
||
.regist_audio_data_user_handler = wbcp_regist_audio_data_user_handler,
|
||
.start_stat_prop = wbcp_start_stat_prop,
|
||
.stop_stat_prop = wbcp_stop_stat_prop,
|
||
};
|
||
|
||
|
||
void get_wbcp_operations_interface(wbcp_operations_interface_type **ops)
|
||
{
|
||
*ops = &wbcp_ops;
|
||
}
|
||
|
||
|
||
u8 get_wbcp_connect_status(void)
|
||
{
|
||
return wbcp.enter;
|
||
}
|
||
|
||
|
||
static void conn_params_show(void *priv)
|
||
{
|
||
wbcp_conn_params_type *conn_params = (wbcp_conn_params_type *)priv;
|
||
log_info("mode = %d", conn_params->mode);
|
||
log_info("channel = %d", conn_params->channel);
|
||
log_info("conn_mcs = %d", conn_params->conn_mcs);
|
||
log_info("conn_phymode = %d", conn_params->conn_phymode);
|
||
log_info("test_mcs = %d", conn_params->test_mcs);
|
||
log_info("test_phymode = %d", conn_params->test_phymode);
|
||
log_info("rssi_thr = %d", conn_params->rssi_thr);
|
||
log_info("dut_reset_flag = %d", conn_params->dut_reset_flag);
|
||
log_info("thradj_fsm = %d, %d",
|
||
conn_params->fsm_timeout.thradj_fsm[0], \
|
||
conn_params->fsm_timeout.thradj_fsm[1]);
|
||
log_info("test_fsm = %d, %d, %d, %d", \
|
||
conn_params->fsm_timeout.test_fsm[0], \
|
||
conn_params->fsm_timeout.test_fsm[1], \
|
||
conn_params->fsm_timeout.test_fsm[2], \
|
||
conn_params->fsm_timeout.test_fsm[3]);
|
||
log_info("test_option: pwr= %d, sen = %d rate = %d, freq = %d ", \
|
||
conn_params->test_option.wifi_pwr_option, \
|
||
conn_params->test_option.wifi_sen_option, \
|
||
conn_params->test_option.wifi_rx_rate_option, \
|
||
conn_params->test_option.wifi_freq_option);
|
||
}
|
||
|
||
|
||
void set_wbcp_mode(u8 mode)
|
||
{
|
||
wbcp.mode = mode;
|
||
}
|
||
|
||
|
||
#endif
|
||
|
||
|
||
|