#include "rf_fcc_main.h" #ifdef RF_FCC_TEST_ENABLE #include "asm/gpio.h" #include "device/uart.h" #include "list.h" #include "datatype.h" #include "wifi/wifi_connect.h" #include "btcontroller_modules.h" #include "utils/syscfg/syscfg_id.h" #include "sock_api/sock_api.h" #include "gpcnt.h" #include "gpio.h" #if 1 #define log_info(x, ...) printf("[RF_FCC_TEST][INFO] " x " ", ## __VA_ARGS__) #define log_err(x, ...) printf("[RF_FCC_TEST][ERR] " x " ", ## __VA_ARGS__) #else #define log_info(...) #define log_err(...) #endif #define WIFI_SIGN_INDEX (250) #define MAX_DGAIN (128) #define MIN_DGAIN (0) #define MAX_XOSC (15) #define MIN_XOSC (0) #define TXINFO_SIZE 4 #define USB_DIR_OUT 0 #define USB_DIR_IN 0x80 #define WIFI_TXWI_HEAD_SIZE 20 #define WIFI_80211_FILL_SIZE 27 //保留一些字节不填充, 为了避开duration段和上层发送1个字节也支持 #define MAC_SYS_CTRL 0x1004 /*MAC_CSR1 */ #define TX_INR_IN_ADJ (500) #define TX_LEN_IN_ADJ (512) static u8 CUR_MODE = 0; static u32 TOTAL_RX_CNT; static struct FCC_TX tx_params; static struct FCC_RX rx_params; static u32 RAND_NUM; static int tx_pid = 0; static void *uart_hdl = NULL; static u8 uart_circlebuf[1024]; static struct list_head head; static u8 sign_ssid[33], sign_pwd[65]; static struct WIFI_SIGN_INFO g_sign_info = {0}; static const struct { const char *string; u8 phy; u8 mcs; } tx_rate_tab[] = { {"1M", 0, 0}, {"2M", 0, 1}, {"5.5M", 0, 2}, {"11M", 0, 3}, {"6M", 1, 0}, {"9M", 1, 1}, {"12M", 1, 2}, {"18M", 1, 3}, {"24M", 1, 4}, {"36M", 1, 5}, {"48M", 1, 6}, {"54M", 1, 7}, {"HTMCS0", 2, 0}, {"HTMCS1", 2, 1}, {"HTMCS2", 2, 2}, {"HTMCS3", 2, 3}, {"HTMCS4", 2, 4}, {"HTMCS5", 2, 5}, {"HTMCS6", 2, 6}, {"HTMCS7", 2, 7}, }; static u8 fcc_str[3][8] = { {"SUCC"}, {"FAIL"}, {"NULL"}, }; struct fcc_info { u8 res[8]; u16 crc; }; static u8 FCC_RSP_ARRAY[] = {0x04, 0x0E, 0x01, 0x01, 0xA1, 0xA2, 0x00}; static u8 FCC_RSP_FAIL_ARRAY[] = {0x04, 0x0E, 0x01, 0x01, 0xA1, 0xA2, 0x01}; static u8 FCC_READY_RSP_ARRAY[] = {0x04, 0x0E, 0x01, 0x01, 0xA1, 0xA2, 0x02}; static u8 FCC_HEART_RSP_ARRAY[] = {0x04, 0x0E, 0x04, 0x01, 0xA1, 0xA3, 0x00, 0x00, 0x00, 0x00}; static u8 FCC_WIFI_ARRAY[] = {0x01, 0xA1, 0xA2, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x01}; static u8 FCC_BT_ARRAY[] = {0x01, 0xA1, 0xA2, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x02}; static u8 FCC_RESET_ARRAY[] = {0x01, 0xA1, 0xA2, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x03}; static u8 FCC_RES_SUCC_ARRAY[] = {0x01, 0xA1, 0xA2, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x04}; static u8 FCC_RES_FAIL_ARRAY[] = {0x01, 0xA1, 0xA2, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05}; static u8 FCC_BT_DUT_ARRAY[] = {0x01, 0xA1, 0xA2, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06}; static u8 FCC_BT_BQB_ARRAY[] = {0x01, 0xA1, 0xA2, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x07}; static u8 FCC_HEART_ARRAY[] = {0x01, 0xA1, 0xA3, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x00}; static u8 FCC_READY_ARRAY[] = {0x01, 0xA1, 0xA3, 0x06, 0x01, 0x02, 0x03, 0x04, 0x05, 0x01}; __attribute__((aligned(4))) static u8 wifi_send_pkg[1564] = { 0xc6, 0x00, 0x00, 0x04, 0xB0, 0x00, 0x04, 0x80, 0x35, 0x01, 0xB6, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /*保留一些字节*/ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, }; int wifi_get_mac(u8 *mac); u32 sdio_mac_rreg(u32 reg); void wf_tx_sine_test(void); void wf_read_xosc(u8 *xosc); void wf_write_xosc(u8 *xosc); void wl_anl_actl_init(char init_sel); void rf_fcc_save_change_mode(u8 mode); void sdio_mac_wreg(u32 wr_addr, u32 dat); void set_pa_config_data(u8 user_data[7]); void wifi_set_channel(unsigned char set_freq); u8 *fcc_common_data_deal(u8 packet_type, u8 *data, u32 len, u32 *rsp_len, u8 *reset); void mp_test_pa_mcs_dgain_set(char mode, char mcs, unsigned char gain); static void read_res(void); static int udp_server_init(int port); void SignalingModeSet(unsigned char enable); static u8 array_cmp(void *a_array, void *b_array, u32 size) { int i; u8 *a = (u8 *)a_array; u8 *b = (u8 *)b_array; for (i = 0; i < size; i++) { if (a[i] != b[i]) { break; } } return (i < size ? 1 : 0); } __attribute__((weak)) const char *rf_fcc_get_uart(void) { return "uart1"; } static u32 comm_dev_tx_data(u8 *buf, u32 len) { return dev_write(uart_hdl, buf, len); } static void comm_dev_recv_task(void *priv) { u8 *buf, *rsp = NULL, reset = 0; u32 rsp_len; u8 uart_data[256]; int len, move_len, crc_check_len; struct fcc_data *fcc = NULL; struct host_data *host = NULL; for (;;) { move_len = 0; memset(uart_data, 0, sizeof(uart_data)); len = dev_read(uart_hdl, uart_data, sizeof(uart_data)); if (len < 0) { continue; } /* put_buf(uart_data, len); */ rsp = fcc_common_data_deal(uart_data[0], &uart_data[1], len - 1, &rsp_len, &reset); if (rsp) { comm_dev_tx_data(rsp, rsp_len); } if (reset) { cpu_reset(); } if (!CUR_MODE) { log_err("no in fcc mode"); continue; } while (move_len < len) { buf = (u8 *)uart_data + move_len; if (buf[0] == 'J' && buf[1] == 'L') { host = zalloc(sizeof(struct host_data)); if (!host) { goto _exit_deal_; } host->self = host; host->flag = 0; fcc = &host->fcc_data; memcpy((u8 *) & (fcc->mark), buf, sizeof(fcc->mark)); memcpy((u8 *) & (fcc->opcode), buf + sizeof(fcc->mark), sizeof(fcc->opcode)); memcpy((u8 *) & (fcc->params_len), buf + sizeof(fcc->mark) + sizeof(fcc->opcode), sizeof(fcc->params_len)); memcpy((u8 *) & (fcc->crc), buf + sizeof(fcc->mark) + sizeof(fcc->opcode) + sizeof(fcc->params_len) + fcc->params_len, sizeof(fcc->crc)); if (fcc->params_len) { fcc->params = (u8 *)zalloc(fcc->params_len); if (!fcc->params) { goto _exit_deal_; } memcpy(fcc->params, buf + sizeof(fcc->mark) + sizeof(fcc->opcode) + sizeof(fcc->params_len), fcc->params_len); } crc_check_len = sizeof(fcc->mark) + sizeof(fcc->opcode) + sizeof(fcc->params_len) + fcc->params_len; if (fcc->crc != CRC16(buf, crc_check_len)) { log_err("%s, crc16 error\n", __FUNCTION__); goto _exit_deal_; } list_add_tail(&host->entry, &head); host = NULL; fcc = NULL; move_len += crc_check_len + sizeof(fcc->crc); } else { break; } } _exit_deal_: if (host) { free(host); host = NULL; } if (fcc) { free(fcc); fcc = NULL; } } } static u8 comm_dev_init(void) { uart_hdl = dev_open(rf_fcc_get_uart(), 0); if (!uart_hdl) { return -1; } dev_ioctl(uart_hdl, UART_SET_CIRCULAR_BUFF_ADDR, (u32)uart_circlebuf); dev_ioctl(uart_hdl, UART_SET_CIRCULAR_BUFF_LENTH, sizeof(uart_circlebuf)); dev_ioctl(uart_hdl, UART_SET_RECV_BLOCK, 1); dev_ioctl(uart_hdl, UART_SET_RECV_TIMEOUT, 1000); dev_ioctl(uart_hdl, UART_START, 0); return 0; } static void wifi_tx_data(u8 *pkg, int len, u32 rate, u8 bw, u8 short_gi)// 最大包1513 { u16 *PktLen = &wifi_send_pkg[0]; u16 *MPDUtotalByteCount = &wifi_send_pkg[10]; *PktLen = WIFI_80211_FILL_SIZE + len + WIFI_TXWI_HEAD_SIZE + 4 - 8; *MPDUtotalByteCount = WIFI_80211_FILL_SIZE + len; if (pkg) { put_buf(pkg, len); memcpy(&wifi_send_pkg[WIFI_TXWI_HEAD_SIZE + WIFI_80211_FILL_SIZE], pkg, len); } else { memset(&wifi_send_pkg[WIFI_TXWI_HEAD_SIZE + WIFI_80211_FILL_SIZE], 0xaa, len); } struct urb urb; urb.pipe = USB_DIR_OUT; urb.complete = NULL; urb.transfer_buffer = wifi_send_pkg; urb.transfer_buffer_length = len + WIFI_TXWI_HEAD_SIZE + WIFI_80211_FILL_SIZE + 4; PTXWI_STRUC pTxWI = TXINFO_SIZE + (u8 *)urb.transfer_buffer; pTxWI->PHYMODE = tx_rate_tab[rate].phy; pTxWI->MCS = tx_rate_tab[rate].mcs; pTxWI->BW = bw; pTxWI->ShortGI = !short_gi; usb_submit_urb(&urb, 0); } static void wifi_rx_frame_cb(void *rxwi, void *header, void *data, u32 len, void *reserve) { PRXWI_STRUC pRxWI = (PRXWI_STRUC *)rxwi; u8 *src_mac = (u8 *)data + 34; /* u8 *src_mac = (u8 *)data + 28; */ /* putchar('A'); */ /* if (pRxWI->BW == rx_params.bandwidth && \ */ /* pRxWI->ShortGI == rx_params.short_gi) { */ /* putchar('B'); */ /* put_buf((u8 *)data, len); */ if (rx_params.filter_enable) { /* log_info("recv_mac:%x:%x:%x:%x:%x:%x\n", src_mac[0], src_mac[1], src_mac[2], src_mac[3], src_mac[4], src_mac[5]); */ if (!array_cmp(src_mac, rx_params.filter_mac, sizeof(rx_params.filter_mac))) { /* putchar('C'); */ TOTAL_RX_CNT++; } } else { TOTAL_RX_CNT++; } /* } */ } static int wifi_event_callback(void *network_ctx, enum WIFI_EVENT event) { static u8 init = 0; struct wifi_store_info wifi_default_mode_parm = {0}; switch (event) { case WIFI_EVENT_MODULE_INIT: puts("|network_user_callback->WIFI_EVENT_MODULE_INIT\n"); if (!strcmp(g_sign_info.str, WIFI_SIGN_STR)) { wifi_default_mode_parm.mode = STA_MODE; strcpy(sign_ssid, g_sign_info.data.ssid); strcpy(sign_pwd, g_sign_info.data.pwd); } else { wifi_default_mode_parm.mode = init ? STA_MODE : MP_TEST_MODE; init = 1; } if (wifi_default_mode_parm.mode <= AP_MODE) { strncpy((char *)wifi_default_mode_parm.ssid[wifi_default_mode_parm.mode - STA_MODE], sign_ssid, sizeof(wifi_default_mode_parm.ssid[wifi_default_mode_parm.mode - STA_MODE]) - 1); strncpy((char *)wifi_default_mode_parm.pwd[wifi_default_mode_parm.mode - STA_MODE], sign_pwd, sizeof(wifi_default_mode_parm.pwd[wifi_default_mode_parm.mode - STA_MODE]) - 1); } wifi_set_default_mode(&wifi_default_mode_parm, 1, wifi_default_mode_parm.mode == STA_MODE); break; case WIFI_EVENT_MODULE_START: puts("|network_user_callback->WIFI_EVENT_MODULE_START\n"); #if 0 u32 tx_rate_control_tab = // 不需要哪个速率就删除掉,可以动态设定 0 | BIT(0) //0:CCK 1M | BIT(1) //1:CCK 2M | BIT(2) //2:CCK 5.5M | BIT(3) //3:OFDM 6M | BIT(4) //4:MCS0/7.2M | BIT(5) //5:OFDM 9M | BIT(6) //6:CCK 11M | BIT(7) //7:OFDM 12M | BIT(8) //8:MCS1/14.4M | BIT(9) //9:OFDM 18M | BIT(10) //10:MCS2/21.7M | BIT(11) //11:OFDM 24M | BIT(12) //12:MCS3/28.9M | BIT(13) //13:OFDM 36M | BIT(14) //14:MCS4/43.3M | BIT(15) //15:OFDM 48M | BIT(16) //16:OFDM 54M | BIT(17) //17:MCS5/57.8M | BIT(18) //18:MCS6/65.0M | BIT(19) //19:MCS7/72.2M ; wifi_set_tx_rate_control_tab(tx_rate_control_tab); #endif break; case WIFI_EVENT_MODULE_STOP: puts("|network_user_callback->WIFI_EVENT_MODULE_STOP\n"); break; case WIFI_EVENT_AP_START: printf("|network_user_callback->WIFI_EVENT_AP_START,CH=%d\n", wifi_get_channel()); break; case WIFI_EVENT_AP_STOP: puts("|network_user_callback->WIFI_EVENT_AP_STOP\n"); break; case WIFI_EVENT_STA_START: puts("|network_user_callback->WIFI_EVENT_STA_START\n"); if (!strcmp(g_sign_info.str, WIFI_SIGN_STR)) { SignalingModeSet(1); wf_write_xosc(g_sign_info.data.xosc); set_pa_config_data(g_sign_info.data.pa); wl_anl_actl_init(0); for (u8 i = 0; i < sizeof(g_sign_info.data.gain); i++) { mp_test_pa_mcs_dgain_set(tx_rate_tab[i].phy, tx_rate_tab[i].mcs, g_sign_info.data.gain[i]); } udp_server_init(30136); #ifdef CONFIG_IPERF_ENABLE extern void iperf_test(void); iperf_test(); #endif } break; case WIFI_EVENT_MODULE_START_ERR: puts("|network_user_callback->WIFI_EVENT_MODULE_START_ERR\n"); break; case WIFI_EVENT_STA_STOP: puts("|network_user_callback->WIFI_EVENT_STA_STOP\n"); break; case WIFI_EVENT_STA_DISCONNECT: puts("|network_user_callback->WIFI_STA_DISCONNECT\n"); break; case WIFI_EVENT_STA_SCAN_COMPLETED: puts("|network_user_callback->WIFI_STA_SCAN_COMPLETED\n"); break; case WIFI_EVENT_STA_CONNECT_SUCC: printf("|network_user_callback->WIFI_STA_CONNECT_SUCC,CH=%d\r\n", wifi_get_channel()); break; case WIFI_EVENT_MP_TEST_START: puts("|network_user_callback->WIFI_EVENT_MP_TEST_START\n"); break; case WIFI_EVENT_MP_TEST_STOP: puts("|network_user_callback->WIFI_EVENT_MP_TEST_STOP\n"); break; case WIFI_EVENT_STA_CONNECT_TIMEOUT_NOT_FOUND_SSID: puts("|network_user_callback->WIFI_STA_CONNECT_TIMEOUT_NOT_FOUND_SSID\n"); cpu_reset(); break; case WIFI_EVENT_STA_CONNECT_ASSOCIAT_FAIL: puts("|network_user_callback->WIFI_STA_CONNECT_ASSOCIAT_FAIL .....\n"); cpu_reset(); break; case WIFI_EVENT_STA_CONNECT_ASSOCIAT_TIMEOUT: puts("|network_user_callback->WIFI_STA_CONNECT_ASSOCIAT_TIMEOUT .....\n"); break; case WIFI_EVENT_STA_NETWORK_STACK_DHCP_SUCC: puts("|network_user_callback->WIFI_EVENT_STA_NETWPRK_STACK_DHCP_SUCC\n"); break; case WIFI_EVENT_STA_NETWORK_STACK_DHCP_TIMEOUT: puts("|network_user_callback->WIFI_EVENT_STA_NETWPRK_STACK_DHCP_TIMEOUT\n"); break; case WIFI_EVENT_P2P_START: puts("|network_user_callback->WIFI_EVENT_P2P_START\n"); break; case WIFI_EVENT_P2P_STOP: puts("|network_user_callback->WIFI_EVENT_P2P_STOP\n"); break; case WIFI_EVENT_P2P_GC_DISCONNECTED: puts("|network_user_callback->WIFI_EVENT_P2P_GC_DISCONNECTED\n"); break; case WIFI_EVENT_P2P_GC_NETWORK_STACK_DHCP_SUCC: puts("|network_user_callback->WIFI_EVENT_P2P_GC_NETWORK_STACK_DHCP_SUCC\n"); break; case WIFI_EVENT_P2P_GC_NETWORK_STACK_DHCP_TIMEOUT: puts("|network_user_callback->WIFI_EVENT_P2P_GC_NETWORK_STACK_DHCP_TIMEOUT\n"); break; case WIFI_EVENT_SMP_CFG_START: puts("|network_user_callback->WIFI_EVENT_SMP_CFG_START\n"); break; case WIFI_EVENT_SMP_CFG_STOP: puts("|network_user_callback->WIFI_EVENT_SMP_CFG_STOP\n"); break; case WIFI_EVENT_SMP_CFG_TIMEOUT: puts("|network_user_callback->WIFI_EVENT_SMP_CFG_TIMEOUT\n"); break; case WIFI_EVENT_SMP_CFG_COMPLETED: puts("|network_user_callback->WIFI_EVENT_SMP_CFG_COMPLETED\n"); break; case WIFI_EVENT_PM_SUSPEND: puts("|network_user_callback->WIFI_EVENT_PM_SUSPEND\n"); break; case WIFI_EVENT_PM_RESUME: puts("|network_user_callback->WIFI_EVENT_PM_RESUME\n"); break; case WIFI_EVENT_AP_ON_ASSOC: puts("WIFI_EVENT_AP_ON_ASSOC\n"); break; case WIFI_EVENT_AP_ON_DISCONNECTED: puts("WIFI_EVENT_AP_ON_DISCONNECTED\n"); break; default: break; } return 0; } static u8 tx_stop_flag = 0; static void tx_test_task(void *priv) { u32 cnt = 0; for (;;) { wifi_tx_data((u8 *)priv, tx_params.packet_len, tx_params.rate, tx_params.bandwidth, tx_params.short_gi); /* putchar('T'); */ if (tx_params.send_interval) { delay_us(tx_params.send_interval); } if (tx_params.npackets) { cnt++; if (cnt >= tx_params.npackets) { tx_pid = 0; return; } } if (tx_stop_flag) { tx_pid = 0; return; } } } static void start_tx_test_data(void *priv) { wifi_set_long_retry(0); wifi_set_short_retry(0); tx_stop_flag = 0; thread_fork("tx_test_task", 10, 256, 0, &tx_pid, tx_test_task, priv); } static void stop_tx_test_data(void) { if (tx_pid) { tx_stop_flag = 1; while (tx_pid) { os_time_dly(1); } } /* if (tx_pid) { */ /* thread_kill(&tx_pid, KILL_FORCE); */ /* tx_pid = 0; */ /* } */ } static void report_data(u8 opcode, void *data, u32 len) { u16 crc; u32 offset; u8 buf[64] = {0}; struct fcc_data *fcc; /* log_info("opcode = %d, len = %d\n", opcode, len); */ ((struct fcc_data *)buf)->mark[0] = 'J'; ((struct fcc_data *)buf)->mark[1] = 'L'; ((struct fcc_data *)buf)->opcode = opcode; ((struct fcc_data *)buf)->params_len = len; offset = sizeof(fcc->mark) + sizeof(fcc->opcode) + sizeof(fcc->params_len); memcpy(buf + offset, (u8 *)data, len); offset += len; crc = CRC16(buf, offset); memcpy(buf + offset, &crc, sizeof(fcc->crc)); offset += sizeof(fcc->crc); comm_dev_tx_data(buf, offset); /* put_buf(buf, offset); */ } static void fcc_data_show(u8 opcode, void *priv) { u8 *mac, mode, *pa; struct FCC_TX *tx; struct FCC_RX *rx; struct FREQ_ADJ *freq_adj; struct PWR_ADJ *pwr_adj; struct WIFI_SIGN *sign; struct FCC_RX_STAT *rxs; switch (opcode) { case OP_FCC_INQ_RAND_NUM: /* log_info("OP_FCC_INQ_RAND_NUM:\n"); */ putchar('H'); break; case OP_FCC_START_TX: tx = (struct FCC_TX *)priv; log_info("\tOP_FCC_START_TX:\n"); log_info("\tpa = %d%d%d%d%d%d%d\n", tx->pa[0], tx->pa[1], \ tx->pa[2], tx->pa[3], tx->pa[4], tx->pa[5], tx->pa[6]); log_info("\txosc = %d, %d\n", tx->xosc[0], tx->xosc[1]); log_info("\tchannel = %d\n", tx->channel); log_info("\tbandwidth = %d\n", tx->bandwidth); log_info("\tshort_gi = %d\n", tx->short_gi); log_info("\tantenna_x = %d\n", tx->antenna_x); log_info("\tpathx_txpower = %d\n", tx->pathx_txpower); log_info("\trate = %s\n", tx_rate_tab[tx->rate].string); log_info("\tnpackets = %d\n", tx->npackets); log_info("\tpacket_len = %d\n", tx->packet_len); log_info("\tsend_interval = %d\n", tx->send_interval); log_info("\tcw_flag = %d\n", tx->cw_flag); break; case OP_FCC_STOP_TX: log_info("\tOP_FCC_STOP_TX:\n"); break; case OP_FCC_START_RX: rx = (struct FCC_RX *)priv; log_info("OP_FCC_START_RX:\n"); log_info("\tpa = %d%d%d%d%d%d%d\n", rx->pa[0], rx->pa[1], \ rx->pa[2], rx->pa[3], rx->pa[4], rx->pa[5], rx->pa[6]); log_info("\txosc = %d, %d\n", rx->xosc[0], rx->xosc[1]); log_info("\tchannel = %d\n", rx->channel); log_info("\tbandwidth = %d\n", rx->bandwidth); log_info("\tshort_gi = %d\n", rx->short_gi); log_info("\tantenna_x = %d\n", rx->antenna_x); log_info("\tfilter_enable = %d\n", rx->filter_enable); log_info("\tfilter_mac = %x:%x:%x:%x:%x:%x\n", rx->filter_mac[0], rx->filter_mac[1], \ rx->filter_mac[2], rx->filter_mac[3], rx->filter_mac[4], rx->filter_mac[5]); break; case OP_FCC_STOP_RX: log_info("OP_FCC_STOP_RX\n"); break; case OP_FCC_SET_MAC: log_info("OP_FCC_SET_MAC:\n"); mac = (u8 *)priv; log_info("MAC = %X:%X:%X:%X:%X:%X\n", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); break; case OP_FCC_INQ_MAC: log_info("OP_FCC_INQ_MAC:\n"); break; case OP_STA_FREQ_ADJ: log_info("OP_STA_FREQ_ADJ:\n"); freq_adj = (struct FREQ_ADJ *)priv; log_info("\tchannel = %d\n", freq_adj->channel); log_info("\trate = %d\n", freq_adj->rate); log_info("\tpathx_txpower = %d\n", freq_adj->pathx_txpower); log_info("\tthr_max = %.2f\n", freq_adj->thr_max); log_info("\tthr_min = %.2f\n", freq_adj->thr_min); log_info("\tmax_cnt = %d\n", freq_adj->max_cnt); log_info("\tstep = %d\n", freq_adj->step); break; case OP_IN_FREQ_ADJ: log_info("OP_IN_FREQ_ADJ:\n"); log_info("\tcur_freq = %.2f\n", *((float *)priv)); break; case OP_STA_PWR_ADJ: log_info("OP_STA_PWR_ADJ:\n"); pwr_adj = (struct PWR_ADJ *)priv; log_info("\tchannel = %d\n", pwr_adj->channel); log_info("\trate = %d\n", pwr_adj->rate); log_info("\tthr_max = %.2f\n", pwr_adj->thr_max); log_info("\tthr_min = %.2f\n", pwr_adj->thr_min); log_info("\tmax_cnt = %d\n", pwr_adj->max_cnt); log_info("\tstep = %d\n", pwr_adj->step); break; case OP_IN_PWR_ADJ: log_info("OP_IN_PWR_ADJ:\n"); log_info("\tcur_pwr = %.2f\n", *((float *)priv)); log_info("\tcur_evm = %.2f\n", *((float *)priv + 1)); log_info("\tcur_mask = %.2f\n", *((float *)priv + 2)); break; case OP_FCC_INQ_DEF_DATA: log_info("OP_FCC_INQ_DEF_DATA:\n"); break; case OP_FCC_SET_PA: log_info("OP_FCC_SET_PA:\n"); pa = (u8 *)priv; log_info("\tpa = %d%d%d%d%d%d%d\n", pa[0], pa[1], pa[2], pa[3], pa[4], pa[5], pa[6]); break; case OP_FCC_SET_CH: log_info("OP_FCC_SET_CH:\n"); log_info("\tCH = %d\n", *(u8 *)priv); break; case OP_FCC_SET_TX_RATE: log_info("OP_FCC_SET_TX_RATE:\n"); log_info("\trate = %s\n", tx_rate_tab[*(u8 *)priv].string); break; case OP_FCC_SET_TX_GAIN: log_info("OP_FCC_SET_TX_GAIN:\n"); log_info("\tgain = %d, rate = %s\n", *(u8 *)priv, tx_rate_tab[tx_params.rate].string); break; case OP_FCC_ENTER_WIFI_SIGN: log_info("OP_FCC_ENTER_WIFI_SIGN:\n"); sign = (struct WIFI_SIGN *)priv; log_info("\tssid = %s\n", sign->ssid); log_info("\tpwd = %s\n", sign->pwd); log_info("\txosc = %d, %d\n", sign->xosc[0], sign->xosc[1]); log_info("\tpa = %d%d%d%d%d%d%d\n", sign->pa[0], sign->pa[1], \ sign->pa[2], sign->pa[3], sign->pa[4], sign->pa[5], sign->pa[6]); log_info("\tB_GAIN = %d, %d, %d, %d\n", sign->gain[0], sign->gain[1], sign->gain[2], sign->gain[3]); log_info("\tG_GAIN = %d, %d, %d, %d, %d, %d, %d, %d\n", sign->gain[4], sign->gain[5], sign->gain[6], sign->gain[7], \ sign->gain[8], sign->gain[9], sign->gain[10], sign->gain[11]); log_info("\tN_GAIN = %d, %d, %d, %d, %d, %d, %d, %d\n", sign->gain[12], sign->gain[13], sign->gain[14], sign->gain[15], \ sign->gain[16], sign->gain[17], sign->gain[18], sign->gain[19]); break; case OP_FCC_START_RX_STAT: rxs = (struct FCC_RX_STAT *)priv; log_info("OP_FCC_START_RX_STAT:\n"); log_info("\tpa = %d%d%d%d%d%d%d\n", rxs->pa[0], rxs->pa[1], \ rxs->pa[2], rxs->pa[3], rxs->pa[4], rxs->pa[5], rxs->pa[6]); log_info("\txosc = %d, %d\n", rxs->xosc[0], rxs->xosc[1]); log_info("\tchannel = %d\n", rxs->channel); log_info("\tbandwidth = %d\n", rxs->bandwidth); log_info("\tshort_gi = %d\n", rxs->short_gi); log_info("\tantenna_x = %d\n", rxs->antenna_x); log_info("\tstat_time = %d\n", rxs->stat_time); log_info("\tfilter_enable = %d\n", rxs->filter_enable); log_info("\tfilter_mac = %x:%x:%x:%x:%x:%x\n", rxs->filter_mac[0], rxs->filter_mac[1], \ rxs->filter_mac[2], rxs->filter_mac[3], rxs->filter_mac[4], rxs->filter_mac[5]); break; case OP_FCC_STOP_RX_STAT: log_info("OP_FCC_STOP_RX_STAT\n"); break; case OP_FCC_INQ_RX_STAT: log_info("OP_FCC_INQ_RX_STAT\n"); break; default: break; } } static void cal_xosc(float cur_freq, u8 *cur_xosc, u8 step) { for (int i = 0; i < step; i++) { if (cur_freq > 0) { if (cur_xosc[0] > cur_xosc[1]) { cur_xosc[1]++; cur_xosc[1] = (cur_xosc[1] > MAX_XOSC) ? MAX_XOSC : cur_xosc[1]; } else { cur_xosc[0]++; cur_xosc[0] = (cur_xosc[0] > MAX_XOSC) ? MAX_XOSC : cur_xosc[0]; } } else { if (cur_xosc[0] > cur_xosc[1]) { cur_xosc[0]--; cur_xosc[0] = (cur_xosc[0] < MIN_XOSC) ? MIN_XOSC : cur_xosc[0]; } else { cur_xosc[1]--; cur_xosc[1] = (cur_xosc[1] < MIN_XOSC) ? MIN_XOSC : cur_xosc[1]; } } } } void cal_gain(u8 rate, u8 gain, u8 *gain_array) { s8 offset; u8 i, range_l, range_r; if (!strcmp(tx_rate_tab[rate].string, "11M")) { range_l = 0; range_r = 3; } else if (!strcmp(tx_rate_tab[rate].string, "54M")) { range_l = 4; range_r = 11; } else if (!strcmp(tx_rate_tab[rate].string, "HTMCS7")) { range_l = 12; range_r = 19; } else { gain_array[rate] = gain; return; } offset = gain - gain_array[rate]; for (i = range_l; i <= range_r; i++) { gain_array[i] += offset; } } #ifdef CONFIG_BT_ENABLE u8 fcc_freq_adj_read(s16 *data) { if (rf_fcc_adj_res_read("offset", data)) { printf("\n --- [RF_FCC_ADJ]fre_offset %d ---- \n", *data); return 1; } else { printf("\n --- [RF_FCC_ADJ]fre_offset NULL ---- \n"); } return 0; } #endif u8 *fcc_common_data_deal(u8 packet_type, u8 *data, u32 len, u32 *rsp_len, u8 *reset) { s32 ret; u8 buf[16] = {0}; static u8 ready = 0; if (len < sizeof(FCC_BT_ARRAY) - 1) { return 0; } buf[0] = packet_type; memcpy(&buf[1], data, sizeof(buf) - 1); if (!array_cmp(buf, FCC_WIFI_ARRAY, sizeof(FCC_WIFI_ARRAY))) { log_info("COMMON OPCODE : change to FCC_WIFI_MODE"); rf_fcc_save_change_mode(FCC_WIFI_MODE); *reset = 1; *rsp_len = sizeof(FCC_RSP_ARRAY); return FCC_RSP_ARRAY; } else if (!array_cmp(buf, FCC_BT_ARRAY, sizeof(FCC_BT_ARRAY))) { log_info("COMMON OPCODE : change to FCC_BT_MODE"); #ifdef CONFIG_BT_ENABLE rf_fcc_save_change_mode(FCC_BT_MODE); *reset = 1; *rsp_len = sizeof(FCC_RSP_ARRAY); return FCC_RSP_ARRAY; #else log_err("no support BT Moudle\n"); *reset = 0; return NULL; #endif } else if (!array_cmp(buf, FCC_BT_DUT_ARRAY, sizeof(FCC_BT_DUT_ARRAY))) { log_info("COMMON OPCODE : change to FCC_BT_DUT_MODE"); #ifdef CONFIG_BT_ENABLE rf_fcc_save_change_mode(FCC_BT_DUT_MODE); *reset = 1; *rsp_len = sizeof(FCC_RSP_ARRAY); return FCC_RSP_ARRAY; #else log_err("no support BT DUT Moudle\n"); *reset = 0; return NULL; #endif } else if (!array_cmp(buf, FCC_BT_BQB_ARRAY, sizeof(FCC_BT_BQB_ARRAY))) { log_info("COMMON OPCODE : change to FCC_BT_BQB_MODE"); #ifdef CONFIG_BT_ENABLE rf_fcc_save_change_mode(FCC_BT_BQB_MODE); *reset = 1; *rsp_len = sizeof(FCC_RSP_ARRAY); return FCC_RSP_ARRAY; #else log_err("no support BT BQB Moudle\n"); *reset = 0; return NULL; #endif } else if (!array_cmp(buf, FCC_RESET_ARRAY, sizeof(FCC_RESET_ARRAY))) { log_info("COMMON OPCODE : RESET"); rf_fcc_save_change_mode(CUR_MODE); *reset = 1; *rsp_len = sizeof(FCC_RSP_ARRAY); return FCC_RSP_ARRAY; } else if (!array_cmp(buf, FCC_HEART_ARRAY, sizeof(FCC_HEART_ARRAY))) { /* log_info("COMMON OPCODE : HEART"); */ putchar('H'); /* log_info("RAND_NUM = %d\n", RAND_NUM); */ memcpy(&FCC_HEART_RSP_ARRAY[6], &RAND_NUM, sizeof(RAND_NUM)); *reset = 0; *rsp_len = sizeof(FCC_HEART_RSP_ARRAY); return FCC_HEART_RSP_ARRAY; } else if (!array_cmp(buf, FCC_RES_SUCC_ARRAY, sizeof(FCC_RES_SUCC_ARRAY))) { log_info("COMMON OPCODE : RES_SUCC"); read_res(); fcc_res_handler(true); /* void clear_efuse(void); */ /* clear_efuse(); */ struct fcc_info info; strcpy(info.res, fcc_str[0]); info.crc = CRC16(info.res, sizeof(info.res)); ret = syscfg_write(WIFI_BT_FCC_RES_FLAG, &info, sizeof(struct fcc_info)); *reset = 0; *rsp_len = sizeof(FCC_RSP_ARRAY); ready = 1; return ((ret == sizeof(struct fcc_info)) ? FCC_RSP_ARRAY : FCC_RSP_FAIL_ARRAY); } else if (!array_cmp(buf, FCC_RES_FAIL_ARRAY, sizeof(FCC_RES_FAIL_ARRAY))) { log_info("COMMON OPCODE : RES_FAIL"); read_res(); fcc_res_handler(false); /* void clear_efuse(void); */ /* clear_efuse(); */ struct fcc_info info; strcpy(info.res, fcc_str[1]); info.crc = CRC16(info.res, sizeof(info.res)); ret = syscfg_write(WIFI_BT_FCC_RES_FLAG, &info, sizeof(struct fcc_info)); *reset = 0; *rsp_len = sizeof(FCC_RSP_ARRAY); ready = 1; return ((ret == sizeof(struct fcc_info)) ? FCC_RSP_ARRAY : FCC_RSP_FAIL_ARRAY); } else if (!array_cmp(buf, FCC_READY_ARRAY, sizeof(FCC_READY_ARRAY))) { log_info("COMMON OPCODE : READY"); *reset = 0; *rsp_len = sizeof(FCC_READY_RSP_ARRAY); return (ready ? NULL : FCC_READY_RSP_ARRAY); } else { *reset = 0; return NULL; } return NULL; } static void fcc_data_deal_task(void *priv) { s32 ret; u8 *xosc; u8 mac[6], gain_array[20]; u8 save_flag, status, cur_dgain, step; float cur_freq, cur_pwr; static u8 adj_cnt, max_cnt; static float thr_max, thr_min; u32 offset, val, last_cnt, res; static u8 cur_xosc[2]; struct wifi_mode_info cur_info = {0}; struct FCC_HIS his = {0}; struct host_data *host; struct fcc_data *fcc; struct FCC_TX *tx; struct FCC_RX *rx; struct FCC_RX_STAT *rxs; struct FREQ_ADJ *freq_adj; struct PWR_ADJ *pwr_adj; struct WIFI_SIGN *sign; u8 none_pa[7] = {0}; static u8 last_pa[7] = {0}, last_ch = 0; for (;;) { if (wifi_is_on()) { log_info("wifi_is_on"); break; } os_time_dly(10); } for (;;) { list_for_each_entry(host, &head, entry) { fcc = &host->fcc_data; fcc_data_show(fcc->opcode, fcc->params); wifi_get_mode_cur_info(&cur_info); if (fcc->opcode > OP_IN_WIFI && fcc->opcode < OP_OUT_WIFI && cur_info.mode != MP_TEST_MODE) { wifi_enter_mp_test_mode(); os_time_dly(2); } #if 0 //for cmd need reset if (fcc->opcode == OP_FCC_ENTER_TEST) { save_flag = (*((u8 *)fcc->params) == FCC_BT_MODE) ? 1 : 0; his.mode = FCC_BT_MODE; } else { save_flag = 0; } if (save_flag) { offset = sizeof(fcc->mark) + sizeof(fcc->opcode) + sizeof(fcc->params_len); memcpy((u8 *)&his.data, (u8 *)fcc, offset); memcpy((u8 *)&his.data + offset, fcc->params, fcc->params_len); offset += fcc->params_len; memcpy((u8 *)&his.data + offset, &fcc->crc, sizeof(fcc->crc)); put_buf(&his, sizeof(struct FCC_HIS)); syscfg_write(CFG_USER_DEFINE_TEST, (u8 *)&his, sizeof(struct FCC_HIS)); cpu_reset(); } #endif memset(&g_sign_info, 0, sizeof(struct WIFI_SIGN_INFO)); syscfg_write(WIFI_SIGN_INDEX, &g_sign_info, sizeof(struct WIFI_SIGN_INFO)); switch (fcc->opcode) { case OP_FCC_INQ_RAND_NUM: /* log_info("RAND_NUM = %d\n", RAND_NUM); */ report_data(OP_FCC_RPT_RAND_NUM, &RAND_NUM, sizeof(RAND_NUM)); break; case OP_FCC_START_TX: tx = (struct FCC_TX *)fcc->params; xosc = ((u8 *)fcc->params) + sizeof(tx->pa); wf_write_xosc(xosc); //认证模式下使用默认PA if (array_cmp(none_pa, tx->pa, sizeof(none_pa))) { set_pa_config_data(tx->pa); wl_anl_actl_init(0); } wifi_set_channel(tx->channel); mp_test_pa_mcs_dgain_set(tx_rate_tab[tx->rate].phy, tx_rate_tab[tx->rate].mcs, tx->pathx_txpower); if (tx->cw_flag) { val = sdio_mac_rreg(MAC_SYS_CTRL); val = val | 0x00000002; sdio_mac_wreg(MAC_SYS_CTRL, val); val = sdio_mac_rreg(MAC_SYS_CTRL); val = val & ~(0x00000002); sdio_mac_wreg(MAC_SYS_CTRL, val); val = sdio_mac_rreg(MAC_SYS_CTRL); val &= ~(1 << 3); sdio_mac_wreg(MAC_SYS_CTRL, val); val = sdio_mac_rreg(MAC_SYS_CTRL); val = val | 0x00000010; sdio_mac_wreg(MAC_SYS_CTRL, val); wf_tx_sine_test(); } stop_tx_test_data(); memcpy(&tx_params, tx, sizeof(struct FCC_TX)); start_tx_test_data(NULL); status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); break; case OP_FCC_STOP_TX: stop_tx_test_data(); status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); break; case OP_FCC_START_RX: stop_tx_test_data(); rx = (struct FCC_RX *)fcc->params; xosc = ((u8 *)fcc->params) + sizeof(tx->pa); wf_write_xosc(xosc); wifi_set_channel(rx->channel); wifi_set_frame_cb(wifi_rx_frame_cb, NULL); memcpy(&rx_params, rx, sizeof(struct FCC_RX)); TOTAL_RX_CNT = 0; status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); break; case OP_FCC_STOP_RX: wifi_set_frame_cb(NULL, NULL); report_data(OP_FCC_RPT_RX_RES, &TOTAL_RX_CNT, sizeof(TOTAL_RX_CNT)); log_info("TOTAL_RX_CNT = %d\n", TOTAL_RX_CNT); TOTAL_RX_CNT = 0; break; case OP_FCC_SET_MAC: wifi_set_mac(fcc->params); status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); break; case OP_FCC_INQ_MAC: memset(mac, 0, sizeof(mac)); wifi_get_mac(mac); log_info("MAC= %X:%X:%X:%X:%X:%X\n", mac[0], mac[1], \ mac[2], mac[3], mac[4], mac[5]); report_data(OP_FCC_RPT_MAC, mac, sizeof(mac)); break; case OP_STA_FREQ_ADJ: freq_adj = (struct FREQ_ADJ *)fcc->params; wf_read_xosc(cur_xosc); wifi_set_channel(freq_adj->channel); adj_cnt = 0; step = freq_adj->step; max_cnt = freq_adj->max_cnt; thr_max = freq_adj->thr_max; thr_min = freq_adj->thr_min; stop_tx_test_data(); memset(&tx_params, 0, sizeof(struct FCC_TX)); tx_params.pathx_txpower = freq_adj->pathx_txpower; tx_params.rate = freq_adj->rate; tx_params.packet_len = TX_LEN_IN_ADJ; tx_params.send_interval = TX_INR_IN_ADJ; log_info("START_FREQ_ADJ: cur_xosc = %d, %d\n", cur_xosc[0], cur_xosc[1]); start_tx_test_data(NULL); status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); break; case OP_IN_FREQ_ADJ: cur_freq = *((float *)fcc->params); adj_cnt++; if (adj_cnt > max_cnt || (cur_freq >= thr_min && cur_freq <= thr_max)) { stop_tx_test_data(); log_info("STOP_FREQ_ADJ: %d, %d, adj_cnt = %d / %d\n", cur_xosc[0], cur_xosc[1], adj_cnt, max_cnt); status = (cur_freq >= thr_min && cur_freq <= thr_max) ? ST_SUCC : ST_FAIL; if (status == ST_SUCC) { ret = syscfg_write(VM_XOSC_INDEX, cur_xosc, sizeof(cur_xosc)); status = (ret == sizeof(cur_xosc)) ? ST_SUCC : ST_FAIL; log_info("FREQ_ADJ_SAVE: ret = %d, status = %d\n", ret, status); } report_data(OP_FIN_FREQ_ADJ, &status, sizeof(status)); } else { cal_xosc(cur_freq, cur_xosc, step); wf_write_xosc(cur_xosc); log_info("IN_FREQ_ADJ: %d, %d, adj_cnt = %d / %d\n", cur_xosc[0], cur_xosc[1], adj_cnt, max_cnt); status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); } break; case OP_STA_PWR_ADJ: pwr_adj = (struct PWR_ADJ *)fcc->params; stop_tx_test_data(); wifi_set_channel(pwr_adj->channel); wifi_get_mcs_dgain(gain_array); cur_dgain = gain_array[pwr_adj->rate]; mp_test_pa_mcs_dgain_set(tx_rate_tab[pwr_adj->rate].phy, tx_rate_tab[pwr_adj->rate].mcs, cur_dgain); adj_cnt = 0; step = pwr_adj->step; max_cnt = pwr_adj->max_cnt; thr_max = pwr_adj->thr_max; thr_min = pwr_adj->thr_min; memset(&tx_params, 0, sizeof(struct FCC_TX)); tx_params.pathx_txpower = cur_dgain; tx_params.rate = pwr_adj->rate; tx_params.packet_len = TX_LEN_IN_ADJ; tx_params.send_interval = TX_INR_IN_ADJ; log_info("START_PWR_ADJ: rate = %s, cur_dgain = %d\n", tx_rate_tab[tx_params.rate].string, cur_dgain); start_tx_test_data(NULL); status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); break; case OP_IN_PWR_ADJ: cur_pwr = *((float *)fcc->params); adj_cnt++; if (adj_cnt > max_cnt || (cur_pwr >= thr_min && cur_pwr <= thr_max)) { stop_tx_test_data(); log_info("STOP_PWR_ADJ: rate = %s, dgain = %d, adj_cnt = %d / %d\n", tx_rate_tab[tx_params.rate].string, cur_dgain, adj_cnt, max_cnt); status = (cur_pwr >= thr_min && cur_pwr <= thr_max) ? ST_SUCC : ST_FAIL; if (status == ST_SUCC) { gain_array[tx_params.rate] = cur_dgain; /* cal_gain(tx_params.rate, cur_dgain, gain_array); */ ret = syscfg_write(VM_WIFI_PA_MCS_DGAIN, gain_array, sizeof(gain_array)); status = (ret == sizeof(gain_array)) ? ST_SUCC : ST_FAIL; log_info("PWR_ADJ_SAVE: ret = %d, status = %d\n", ret, status); } report_data(OP_FIN_PWR_ADJ, &status, sizeof(status)); } else { if (cur_pwr < thr_min) { cur_dgain = (cur_dgain + step) > MAX_DGAIN ? MAX_DGAIN : (cur_dgain + step); } else if (cur_pwr > thr_max) { cur_dgain = (cur_dgain - step) < MIN_DGAIN ? MIN_DGAIN : (cur_dgain - step); } log_info("IN_PWR_ADJ: rate = %s, dgain = %d, adj_cnt = %d / %d\n", tx_rate_tab[tx_params.rate].string, cur_dgain, adj_cnt, max_cnt); stop_tx_test_data(); mp_test_pa_mcs_dgain_set(tx_rate_tab[tx_params.rate].phy, tx_rate_tab[tx_params.rate].mcs, cur_dgain); start_tx_test_data(NULL); status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); } break; case OP_FCC_INQ_DEF_DATA: struct WIFI_DEF_DATA def_data = {0}; syscfg_read(VM_WIFI_PA_DATA, (u8 *)def_data.pa, sizeof(def_data.pa)); syscfg_read(VM_XOSC_INDEX, (u8 *)def_data.xosc, sizeof(def_data.xosc)); syscfg_read(VM_WIFI_PA_MCS_DGAIN, (u8 *)def_data.mcs_dgain, sizeof(def_data.mcs_dgain)); report_data(OP_FCC_RPT_DEF_DATA, &def_data, sizeof(struct WIFI_DEF_DATA)); break; case OP_FCC_SET_PA: if (array_cmp(last_pa, fcc->params, sizeof(last_pa))) { set_pa_config_data(fcc->params); wl_anl_actl_init(0); memcpy(last_pa, fcc->params, sizeof(last_pa)); } else { log_info("the same PA\n"); } status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); break; case OP_FCC_SET_CH: if (last_ch != *(fcc->params)) { last_ch = *(fcc->params); wifi_set_channel(*(fcc->params)); } else { log_info("the same CH\n"); } status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); break; case OP_FCC_SET_TX_RATE: if (tx_pid) { stop_tx_test_data(); tx_params.rate = *(fcc->params); start_tx_test_data(NULL); status = ST_SUCC; } else { status = ST_FAIL; } report_data(OP_FCC_RPT_ST, &status, sizeof(status)); break; case OP_FCC_SET_TX_GAIN: if (tx_pid) { mp_test_pa_mcs_dgain_set(tx_rate_tab[tx_params.rate].phy, tx_rate_tab[tx_params.rate].mcs, *(fcc->params)); status = ST_SUCC; } else { status = ST_FAIL; } report_data(OP_FCC_RPT_ST, &status, sizeof(status)); break; case OP_FCC_ENTER_WIFI_SIGN: sign = (struct WIFI_SIGN *)fcc->params; strcpy(&g_sign_info.str, WIFI_SIGN_STR); memcpy(&g_sign_info.data, sign, sizeof(struct WIFI_SIGN)); syscfg_write(WIFI_SIGN_INDEX, &g_sign_info, sizeof(struct WIFI_SIGN_INFO)); strcpy(sign_ssid, sign->ssid); strcpy(sign_pwd, sign->pwd); stop_tx_test_data(); wifi_set_frame_cb(NULL, NULL); /* extern u8 ntp_get_time_init; */ /* ntp_get_time_init = 0; */ wifi_off(); wifi_on(); status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); #ifdef CONFIG_IPERF_ENABLE extern void iperf_test(void); iperf_test(); #endif break; case OP_FCC_START_RX_STAT: stop_tx_test_data(); rxs = (struct FCC_RX_STAT *)fcc->params; xosc = ((u8 *)fcc->params) + sizeof(tx->pa); wf_write_xosc(xosc); wifi_set_channel(rxs->channel); wifi_set_frame_cb(wifi_rx_frame_cb, NULL); memcpy(&rx_params, rxs, sizeof(struct FCC_RX)); last_cnt = 0; TOTAL_RX_CNT = 0; status = ST_SUCC; report_data(OP_FCC_RPT_ST, &status, sizeof(status)); break; case OP_FCC_STOP_RX_STAT: wifi_set_frame_cb(NULL, NULL); report_data(OP_FCC_RPT_RX_RES, &TOTAL_RX_CNT, sizeof(TOTAL_RX_CNT)); log_info("TOTAL_RX_CNT = %d\n", TOTAL_RX_CNT); TOTAL_RX_CNT = 0; break; case OP_FCC_INQ_RX_STAT: res = TOTAL_RX_CNT - last_cnt; log_info("RX_STAT: res = %d, now = %d, last = %d\n", res, TOTAL_RX_CNT, last_cnt); last_cnt = TOTAL_RX_CNT; report_data(OP_FCC_RPT_RX_STAT, &res, sizeof(res)); break; default: break; } list_del(&host->entry); free(fcc->params); free(host->self); break; } os_time_dly(1); } } u8 get_fcc_info(void) { u8 ret = FCC_NULL; struct fcc_info info; if (syscfg_read(WIFI_BT_FCC_RES_FLAG, &info, sizeof(struct fcc_info)) == sizeof(struct fcc_info)) { if (info.crc == CRC16(info.res, sizeof(info.res))) { if (!strcmp(fcc_str[0], info.res)) { ret = FCC_SUCC; } else if (!strcmp(fcc_str[1], info.res)) { ret = FCC_FAIL; } } } log_info("==================FCC adjust %s==================\n", fcc_str[ret]); return ret; } void clear_efuse(void) { u8 xosc[2]; xosc[0] = wifi_calibration_param.xosc_l; xosc[1] = wifi_calibration_param.xosc_r; syscfg_write(VM_XOSC_INDEX, xosc, 2); syscfg_write(VM_WIFI_PA_MCS_DGAIN, wifi_calibration_param.mcs_dgain, sizeof(wifi_calibration_param.mcs_dgain)); #ifdef CONFIG_BT_ENABLE s16 adj_freq = -30; u8 ble_power = 6, bt_power = 8; rf_fcc_adj_res_write("ble", &ble_power); rf_fcc_adj_res_write("edr", &bt_power); rf_fcc_adj_res_write("offset", &adj_freq); #endif } static void create_cmd_data(u8 opcode, void *data, u32 len) { u16 crc; u32 offset; u8 buf[160] = {0}; struct fcc_data *fcc; /* log_info("opcode = %d, len = %d\n", opcode, len); */ ((struct fcc_data *)buf)->mark[0] = 'J'; ((struct fcc_data *)buf)->mark[1] = 'L'; ((struct fcc_data *)buf)->opcode = opcode; ((struct fcc_data *)buf)->params_len = len; offset = sizeof(fcc->mark) + sizeof(fcc->opcode) + sizeof(fcc->params_len); if (data) { memcpy(buf + offset, (u8 *)data, len); } offset += len; crc = CRC16(buf, offset); memcpy(buf + offset, &crc, sizeof(fcc->crc)); offset += sizeof(fcc->crc); put_buf(buf, offset); } static void create_fcc_cmd_demo(void) { log_info("================OP_FCC_ENTER_WIFI_SIGN================\n"); struct WIFI_SIGN sign = {0}; strcpy(sign.ssid, "GJ"); strcpy(sign.pwd, "8888888899"); memset(sign.xosc, 0x0b, sizeof(sign.xosc)); memset(sign.pa, 0x07, sizeof(sign.pa)); memset(sign.gain, 32, sizeof(sign.gain)); create_cmd_data(OP_FCC_ENTER_WIFI_SIGN, &sign, sizeof(struct WIFI_SIGN)); log_info("====================OP_FCC_STOP_TX====================\n"); create_cmd_data(OP_FCC_STOP_TX, NULL, 0); log_info("====================OP_FCC_STOP_RX====================\n"); create_cmd_data(OP_FCC_STOP_RX, NULL, 0); log_info("==================OP_FCC_INQ_RAND_NUM=================\n"); create_cmd_data(OP_FCC_INQ_RAND_NUM, NULL, 0); log_info("====================OP_FCC_SET_PA====================\n"); u8 pa_set[7] = {7, 7, 7, 7, 7, 7, 7}; create_cmd_data(OP_FCC_SET_PA, pa_set, sizeof(pa_set)); log_info("====================OP_FCC_SET_CH====================\n"); u8 ch_set = 7; create_cmd_data(OP_FCC_SET_CH, &ch_set, sizeof(ch_set)); log_info("====================OP_FCC_SET_TX_RATE====================\n"); u8 rate_set = 1; create_cmd_data(OP_FCC_SET_TX_RATE, &rate_set, sizeof(rate_set)); log_info("====================OP_FCC_SET_TX_GAIN====================\n"); u8 gain_set = 72; create_cmd_data(OP_FCC_SET_TX_GAIN, &gain_set, sizeof(gain_set)); log_info("====================OP_FCC_SET_MAC====================\n"); u8 mac[6]; memset(mac, 0xaa, 6); create_cmd_data(OP_FCC_SET_MAC, mac, 6); log_info("====================OP_FCC_INQ_MAC====================\n"); create_cmd_data(OP_FCC_INQ_MAC, NULL, 0); log_info("=================OP_FCC_INQ_DEF_DATA==================\n"); create_cmd_data(OP_FCC_INQ_DEF_DATA, NULL, 0); log_info("====================TX_TEST, XOSC=====================\n"); struct FCC_TX data = {0}; u8 pa[7] = {1, 7, 4, 7, 9, 1, 7}; u8 xosc[2] = {11, 10}; memcpy(data.pa, pa, 7); data.channel = 7; data.bandwidth = 0; data.short_gi = 0; data.antenna_x = 0; data.pathx_txpower = 32; data.rate = 3; data.npackets = 0; data.packet_len = 1000; data.send_interval = 1000; data.cw_flag = 0; for (int i = 0; i < 16; i++) { xosc[0] = i; xosc[1] = i; memcpy(data.xosc, xosc, 2); /* log_info("xosc = %d, %d\n", xosc[0], xosc[1]); */ /* create_cmd_data(OP_FCC_START_TX, &data, sizeof(struct FCC_TX)); */ } log_info("====================TX_TEST, DGAIN=====================\n"); xosc[0] = 11; xosc[1] = 10; memcpy(data.pa, pa, 7); memcpy(data.xosc, xosc, 2); data.channel = 7; data.bandwidth = 0; data.short_gi = 0; data.antenna_x = 0; data.pathx_txpower = 32; data.rate = 3; data.npackets = 0; data.packet_len = 1000; data.send_interval = 1000; data.cw_flag = 0; for (int i = 0; i < 5; i++) { data.pathx_txpower = 32 * i; log_info("dgain = %d\n", data.pathx_txpower); create_cmd_data(OP_FCC_START_TX, &data, sizeof(struct FCC_TX)); } log_info("========================RX_TEST========================\n"); struct FCC_RX rx = {0}; xosc[0] = 11; xosc[1] = 10; memcpy(rx.pa, pa, 7); memcpy(rx.xosc, xosc, 2); rx.channel = 7; rx.bandwidth = 0; rx.short_gi = 0; rx.antenna_x = 0; rx.filter_enable = 0; create_cmd_data(OP_FCC_START_RX, &rx, sizeof(struct FCC_RX)); log_info("========================RX_STAT_TEST========================\n"); struct FCC_RX_STAT rxs = {0}; xosc[0] = 11; xosc[1] = 10; memcpy(rxs.pa, pa, 7); memcpy(rxs.xosc, xosc, 2); rxs.channel = 7; rxs.bandwidth = 0; rxs.short_gi = 0; rxs.antenna_x = 0; rxs.stat_time = 1; rxs.filter_enable = 0; create_cmd_data(OP_FCC_START_RX_STAT, &rxs, sizeof(struct FCC_RX_STAT)); log_info("====================OP_FCC_STOP_RX_STAT====================\n"); create_cmd_data(OP_FCC_STOP_RX_STAT, NULL, 0); log_info("====================OP_FCC_INQ_RX_STAT====================\n"); create_cmd_data(OP_FCC_INQ_RX_STAT, NULL, 0); log_info("====================freq_adj=====================\n"); float cur_freq; struct FREQ_ADJ adj = {0}; adj.channel = 7; adj.rate = 3; adj.pathx_txpower = 32; adj.thr_max = 5.5; adj.thr_min = -5.5; adj.max_cnt = 3; adj.step = 1; create_cmd_data(OP_STA_FREQ_ADJ, &adj, sizeof(struct FREQ_ADJ)); adj.step = 2; create_cmd_data(OP_STA_FREQ_ADJ, &adj, sizeof(struct FREQ_ADJ)); cur_freq = 30.02; create_cmd_data(OP_IN_FREQ_ADJ, &cur_freq, sizeof(float)); cur_freq = 20.03; create_cmd_data(OP_IN_FREQ_ADJ, &cur_freq, sizeof(float)); cur_freq = 10.05; create_cmd_data(OP_IN_FREQ_ADJ, &cur_freq, sizeof(float)); cur_freq = 4.5; create_cmd_data(OP_IN_FREQ_ADJ, &cur_freq, sizeof(float)); log_info("=====================pwr_adj=====================\n"); s8 cur_pwr; struct PWR_ADJ pwr_adj = {0}; float res_buf[3]; pwr_adj.channel = 7; pwr_adj.rate = 3; pwr_adj.thr_max = 15.15; pwr_adj.thr_min = 10.10; pwr_adj.max_cnt = 3; pwr_adj.step = 16; create_cmd_data(OP_STA_PWR_ADJ, &pwr_adj, sizeof(struct PWR_ADJ)); res_buf[1] = 66.66; res_buf[2] = 77.77; res_buf[0] = 2.2; create_cmd_data(OP_IN_PWR_ADJ, res_buf, sizeof(res_buf)); res_buf[0] = 5.5; create_cmd_data(OP_IN_PWR_ADJ, res_buf, sizeof(res_buf)); res_buf[0] = 6.6; create_cmd_data(OP_IN_PWR_ADJ, res_buf, sizeof(res_buf)); res_buf[0] = 12.12; create_cmd_data(OP_IN_PWR_ADJ, res_buf, sizeof(res_buf)); } u8 get_rf_fcc_mode(void) { return CUR_MODE; } static u8 fcc_enter_io_trigger(void) { u8 cnt = 0; gpio_set_pull_up(CONFIG_RF_FCC_TRIGGER_IO_PORT, !CONFIG_RF_FCC_TRIGGER_IO_STATE); gpio_set_pull_down(CONFIG_RF_FCC_TRIGGER_IO_PORT, CONFIG_RF_FCC_TRIGGER_IO_STATE); gpio_direction_input(CONFIG_RF_FCC_TRIGGER_IO_PORT); for (cnt = 0; cnt < CONFIG_RF_FCC_TRIGGER_IO_CNT; cnt++) { if (gpio_read(CONFIG_RF_FCC_TRIGGER_IO_PORT) != CONFIG_RF_FCC_TRIGGER_IO_STATE) { break; } os_time_dly(1); } return (cnt >= CONFIG_RF_FCC_TRIGGER_IO_CNT) ? 1 : 0; } static u8 fcc_enter_gpcnt_trigger(void) { u8 cnt = 0; u32 gpcnt = 1; void *gpcnt_hd = NULL; gpcnt_hd = dev_open("gpcnt", NULL); if (!gpcnt_hd) { log_info("gpcnt open err\n"); return 0; } for (cnt = 0; cnt < CONFIG_RF_FCC_GPCNT_TRIGGER_CNT; cnt++) { dev_ioctl(gpcnt_hd, IOCTL_GET_GPCNT, (u32)&gpcnt); if (gpcnt < CONFIG_RF_FCC_GPCNT_TRIGGER_FREQ_L || \ gpcnt > CONFIG_RF_FCC_GPCNT_TRIGGER_FREQ_H) { break; } os_time_dly(1); } dev_close(gpcnt_hd); return (cnt >= CONFIG_RF_FCC_GPCNT_TRIGGER_CNT) ? 1 : 0; } __attribute__((weak))u8 fcc_enter_user_def(void) { return 0; } void rf_fcc_save_change_mode(u8 mode) { u8 check_len; struct fcc_mode info = {0}; strcpy(info.str, "change"); info.mode = mode; check_len = sizeof(struct fcc_mode) - sizeof(&info.crc); info.crc = CRC16(&info, check_len); syscfg_write(WIFI_BT_FCC_CHANGE, &info, sizeof(struct fcc_mode)); } u8 rf_fcc_get_change_mode(void) { u8 check_len; struct fcc_mode info = {0}; if (syscfg_read(WIFI_BT_FCC_CHANGE, &info, sizeof(struct fcc_mode)) == sizeof(struct fcc_mode)) { check_len = sizeof(struct fcc_mode) - sizeof(&info.crc); if (CRC16(&info, check_len) == info.crc) { CUR_MODE = info.mode; log_info("%s, CUR_MODE = %d\n", __FUNCTION__, CUR_MODE); #ifndef RF_FCC_MODE_KEEP memset(&info, 0, sizeof(struct fcc_mode)); syscfg_write(WIFI_BT_FCC_CHANGE, &info, sizeof(struct fcc_mode)); #endif return CUR_MODE; } } return 0; } u8 rf_fcc_test_init(void) { u8 mode; u8 mac[6] = {0}; struct FCC_HIS his = {0}; struct host_data *host; struct fcc_data *fcc; if (!(mode = rf_fcc_get_change_mode())) { #if (CONFIG_RF_FCC_TRIGGER_MODE == IO_TRIGGER_MODE) if (!fcc_enter_io_trigger()) { return 0; } #elif (CONFIG_RF_FCC_TRIGGER_MODE == GPCNT_TRIGGER_MODE) if (!fcc_enter_gpcnt_trigger()) { return 0; } #elif (CONFIG_RF_FCC_TRIGGER_MODE == USER_DEF_MODE) if (!fcc_enter_user_def()) { return 0; } #elif (CONFIG_RF_FCC_TRIGGER_MODE == AUTO_STARTUP_MODE) #else return 0; #endif } if (syscfg_read(WIFI_SIGN_INDEX, &g_sign_info, sizeof(struct WIFI_SIGN_INFO)) == sizeof(struct WIFI_SIGN_INFO)) { if (!strcmp(g_sign_info.str, WIFI_SIGN_STR)) { log_info("%s, %s\n", __FUNCTION__, g_sign_info.str); mode = FCC_WIFI_MODE; CUR_MODE = FCC_WIFI_MODE; fcc_data_show(OP_FCC_ENTER_WIFI_SIGN, &g_sign_info.data); SignalingModeSet(1); } } get_fcc_info(); /* create_fcc_cmd_demo(); */ RAND_NUM = random32(0) & 2147483647; log_info("RAND_NUM = %ld\n", RAND_NUM); INIT_LIST_HEAD(&head); #if 0 //for cmd need reset int read_ret = syscfg_read(CFG_USER_DEFINE_TEST, (u8 *)&his, sizeof(struct FCC_HIS)); if (read_ret == sizeof(struct FCC_HIS)) { put_buf(&his, sizeof(struct FCC_HIS)); if (his.mode == FCC_WIFI_MODE) { host = zalloc(sizeof(struct host_data)); host->flag = 1; host->self = host; fcc = &host->fcc_data; memcpy((u8 *) & (fcc->mark), his.data, sizeof(fcc->mark)); memcpy((u8 *) & (fcc->opcode), his.data + sizeof(fcc->mark), sizeof(fcc->opcode)); memcpy((u8 *) & (fcc->params_len), his.data + sizeof(fcc->mark) + sizeof(fcc->opcode), sizeof(fcc->params_len)); memcpy((u8 *) & (fcc->crc), his.data + sizeof(fcc->mark) + sizeof(fcc->opcode) + sizeof(fcc->params_len) + fcc->params_len, sizeof(fcc->crc)); fcc->params = (u8 *)zalloc(fcc->params_len); memcpy(fcc->params, his.data + sizeof(fcc->mark) + sizeof(fcc->opcode) + sizeof(fcc->params_len), fcc->params_len); list_add_tail(&host->entry, &head); CUR_MODE = FCC_WIFI_MODE; } else if (his.mode == FCC_BT_MODE) { CUR_MODE = FCC_BT_MODE; } memset(&his, 0xaa, sizeof(struct FCC_HIS)); int ret = syscfg_write(CFG_USER_DEFINE_TEST, &his, sizeof(struct FCC_HIS)); log_info("syscfg_write, ret = %d\n", ret); if (CUR_MODE == FCC_BT_MODE) { return 0; } } #endif if (mode == FCC_BT_MODE) { #ifdef CONFIG_BT_ENABLE wifi_set_mac(mac); config_btctler_mode = BT_FCC; config_btctler_hci_standard = 1; fcc_bt_ble_module_init(); return FCC_BT_MODE; #else return 0; #endif } else if (mode == FCC_BT_DUT_MODE) { #ifdef CONFIG_BT_ENABLE wifi_set_mac(mac); config_btctler_mode = BT_NORMAL; config_btctler_hci_standard = 0; fcc_bt_ble_module_init(); return FCC_BT_MODE; #else return 0; #endif } else if (mode == FCC_BT_BQB_MODE) { #ifdef CONFIG_BT_ENABLE wifi_set_mac(mac); config_btctler_mode = BT_BQB; config_btctler_hci_standard = 1; fcc_bt_ble_module_init(); return FCC_BT_MODE; #else return 0; #endif } else if (mode == FCC_WIFI_MODE) { //wifi_set_sta_connect_timeout(10000); wifi_set_event_callback(wifi_event_callback); wifi_on(); comm_dev_init(); thread_fork("comm_dev_recv_task", 28, 256, 0, NULL, comm_dev_recv_task, NULL); thread_fork("fcc_data_deal_task", 26, 1024, 0, NULL, fcc_data_deal_task, NULL); extern void wifi_set_pwr(unsigned char pwr_sel); wifi_set_pwr(6); return FCC_WIFI_MODE; } comm_dev_init(); thread_fork("comm_dev_recv_task", 28, 256, 0, NULL, comm_dev_recv_task, NULL); #if ((CONFIG_RF_FCC_TRIGGER_MODE == IO_TRIGGER_MODE) || \ (CONFIG_RF_FCC_TRIGGER_MODE == GPCNT_TRIGGER_MODE) || \ (CONFIG_RF_FCC_TRIGGER_MODE == USER_DEF_MODE) || \ (CONFIG_RF_FCC_TRIGGER_MODE == AUTO_STARTUP_MODE)) return FCC_WAIT_MODE; #endif return 0; } void wifi_tx_data_test(u8 channel, u8 power, u8 rate, u8 *packet, u32 packet_len, u32 npackets, u32 tx_interval) { if (packet_len > 1513 || packet_len < 1) { log_err("%s, params err, packet_len = %d\n", __FUNCTION__, packet_len); } stop_tx_test_data(); memset(&tx_params, 0, sizeof(struct FCC_TX)); tx_params.rate = rate; tx_params.packet_len = packet_len; tx_params.npackets = npackets; tx_params.send_interval = tx_interval; wifi_set_channel(channel); mp_test_pa_mcs_dgain_set(tx_rate_tab[rate].phy, tx_rate_tab[rate].mcs, power); start_tx_test_data(packet); } static void read_res(void) { u8 bt_power = 0, ble_power = 0; struct wifi_calibration_param cal = {0}; #ifdef CONFIG_BT_ENABLE rf_fcc_adj_res_read("edr", &bt_power); rf_fcc_adj_res_read("ble", &ble_power); #endif syscfg_read(VM_XOSC_INDEX, &cal.xosc_l, 2); syscfg_read(VM_WIFI_PA_MCS_DGAIN, &cal.mcs_dgain, sizeof(cal.mcs_dgain)); syscfg_read(VM_WIFI_PA_DATA, &cal.pa_trim_data, sizeof(cal.pa_trim_data)); log_info("=========================CAL_RES=========================\n"); #ifdef CONFIG_BT_ENABLE log_info("bt_power = %d, ble_power = %d\n", bt_power, ble_power); #endif log_info("xosc_l = %d, xosc_r = %d\n", cal.xosc_l, cal.xosc_r); log_info("PA : \n"); put_buf(&cal.pa_trim_data, sizeof(cal.pa_trim_data)); log_info("MCS_GAIN : \n"); put_buf(&cal.mcs_dgain, sizeof(cal.mcs_dgain)); log_info("=========================CAL_RES=========================\n"); } static void udp_recv_handler(void *socket_fd) { static u32 sock_rcv_cnt; struct sockaddr_in remote_addr; socklen_t len = sizeof(remote_addr); int recv_len; u8 recv_buf[4]; u32 start_time = 0; u32 debug_flag = 0; for (;;) { recv_len = sock_recvfrom(socket_fd, recv_buf, sizeof(recv_buf), 0, (struct sockaddr *)&remote_addr, &len); if (recv_len > 0) { if (start_time == 0) { start_time = timer_get_ms(); } ++sock_rcv_cnt; } if (timer_get_ms() - start_time >= 30 * 1000) { if (debug_flag == 0) { debug_flag = 1; printf("\r\n\r\n STA MODE UDP RECV PKG CNT = %d\r\n\r\n", sock_rcv_cnt); } } } } static int udp_server_init(int port) { static void *socket_fd; struct sockaddr_in local_addr = {0}; local_addr.sin_family = AF_INET; local_addr.sin_addr.s_addr = htonl(INADDR_ANY); local_addr.sin_port = htons(port); socket_fd = sock_reg(AF_INET, SOCK_DGRAM, 0, NULL, NULL); if (socket_fd == NULL) { printf("%s build socket fail\n", __FILE__); return -1; } if (sock_bind(socket_fd, (struct sockaddr *)&local_addr, sizeof(struct sockaddr))) { printf("%s sock_bind fail\n", __FILE__); return -1; } sock_set_recv_timeout(socket_fd, 3000); //创建线程，用于接收tcp_client的数据 if (thread_fork("udp_recv_handler", 25, 512, 0, NULL, udp_recv_handler, socket_fd) != OS_NO_ERR) { printf("%s thread fork fail\n", __FILE__); return -1; } return 0; } __attribute__((weak))void fcc_res_handler(u8 res) { log_info("%s, res = %d\n", __func__, res); if (res == true) { gpio_direction_output(CONFIG_RF_FCC_TRIGGER_IO_PORT, 1); } else { gpio_direction_output(CONFIG_RF_FCC_TRIGGER_IO_PORT, 0); } } u8 fcc_wifi_sign_dgain_set(u8 phy, u8 mcs) { u8 idx; if (!strcmp(g_sign_info.str, WIFI_SIGN_STR)) { for (idx = 0; idx < ARRAY_SIZE(tx_rate_tab); idx++) { if (tx_rate_tab[idx].phy == phy && tx_rate_tab[idx].mcs == mcs) { break; } } if (idx >= ARRAY_SIZE(tx_rate_tab)) { return FALSE; } printf("%s, dgain = %d\n", tx_rate_tab[idx].string, g_sign_info.data.gain[idx]); mp_test_pa_mcs_dgain_set(phy, mcs, g_sign_info.data.gain[idx]); return TRUE; } return FALSE; } #endif