Google Git
Sign in
nest-open-source / nest-learning-thermostat / 5.9.1 / cypress-utility / refs/heads/master / . / wl / src / wl / exe / wluc_proxd.c
blob: ab03cb14bb56496ecb9b2f2c52827415ad08a7c9 [file] [log] [blame]
/*
* wl proxd command module
*
* Broadcom Proprietary and Confidential. Copyright (C) 2017,
* All Rights Reserved.
*
* This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom;
* the contents of this file may not be disclosed to third parties, copied
* or duplicated in any form, in whole or in part, without the prior
* written permission of Broadcom.
*
*
* <<Broadcom-WL-IPTag/Proprietary:>>
*
* $Id: wluc_proxd.c 458728 2014-02-27 18:15:25Z $
*/
#ifdef WIN32
#include <windows.h>
#endif
#include <wlioctl.h>
#if defined(DONGLEBUILD)
#include <typedefs.h>
#include <osl.h>
#endif
/* Because IL_BIGENDIAN was removed there are few warnings that need
* to be fixed. Windows was not compiled earlier with IL_BIGENDIAN.
* Hence these warnings were not seen earlier.
* For now ignore the following warnings
*/
#ifdef WIN32
#pragma warning(push)
#pragma warning(disable : 4244)
#pragma warning(disable : 4761)
#endif
#include <bcmutils.h>
#include <bcmendian.h>
#include "wlu_common.h"
#include "wlu.h"
#ifdef WIN32
#define bzero(b, len) memset((b), 0, (len))
#endif
#ifdef LINUX
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <netinet/in.h>
#include <net/if.h>
#include <linux/if_packet.h>
#endif /* LINUX */
#include <miniopt.h>
#include <errno.h>
static cmd_func_t wl_proxd;
static cmd_func_t wl_proxd_tune;
static cmd_func_t wl_proxd_collect;
static cmd_func_t wl_proxd_params;
static cmd_func_t wl_proxd_status;
static cmd_func_t wl_proxd_payload;
#if defined(linux)
static cmd_func_t wl_proxd_event_check;
#endif /* linux */
static cmd_func_t wl_proxd_report;
#if defined(WL_NAN)
static cmd_func_t wl_nan_ranging_config;
static cmd_func_t wl_nan_ranging_start;
static cmd_func_t wl_nan_ranging_results_host;
#endif /* WL_NAN */
#define WL_PROXD_PAYLOAD_LEN 1026
#define TOF_DEFAULT_FTMCNT_SEQ 3
#define PROXD_PARAMS_USAGE \
"\tUsage: wl proxd_params method [-c channel] [-i interval] [-d duration] [-s rssi_thresh]" \
" [-p tx_power] [-r tx_rate] [-t timeout] [-m maxconvergetime] [-g <xx:xx:xx:xx:xx:xx>]" \
" [-y retrycnt]\n\n" \
"\tMandatory args:\n" \
"\t\tmethod: == 1 (RSSI) or == 2 (TOF) methods are supported) \n\n" \
"\tOptional method specific args - for method 1: \n" \
"\t\t-c chanspec : (all methods) channel to use for Proximity Detection\n" \
"\t\t : e.g: 161/80, if [/BW] omitted, driver will assume 20Mhz by default\n" \
"\t\t-i interval : (RSSI method) interval between neighbor finding attempts (in TU)\n" \
"\t\t : (Once associated as STA mode, this value is ignored and\n" \
"\t\t : the interval follows DTIM)\n" \
"\t\t-d duration : (RSSI method) duration of neighbor finding attempts (in ms)\n" \
"\t\t : == dwelling time on home channel specificed by -c channel\n" \
"\t\t-s rssi_thresh : RSSI threshold for Proximity Detection criteria (in dBm)\n" \
"\t\t : (-99 to -1)\n" \
"\t\t-p tx_power : (RSSI method) tx power of Proximity Detection frames (in dBm)\n" \
"\t\t-r tx_rate : (all methods) tx rate of Proximity Detection frames (in Mbps)\n" \
"\t\t : (TOF) tx_rate format is {R|{hM|vM[xS]}[s][l][g]}[eT][bB]\n" \
"\t\t : R - legacy rate, hM - HT MCS index[0-23], " \
"vMxS - VHT MCS index[0-9] and Nss[1-8]\n" \
"\t\t : s - Use STBC expansion, l - Use LDPC encoding, " \
"g - SGI, Short Guard Interval\n" \
"\t\t : eT - Tx expansion, number of tx chains[0-3], " \
"bB - tx bandwidth, MHz: 20, 40, 80\n" \
"\t\t-t timeout : (all methods) state machine receive timeout of Proximity Detection " \
"frames (in ms)\n" \
"\t\t-m maxconverge : (RSSI method) device stays up for a whole interval to detect the peer\n" \
"\t\t : when no peer found after max converge time (in ms)\n\n" \
"\t\t-g tgt_mac : (TOF) proximity target mac address for a method \n" \
"\t\t-f ftm_cnt : (TOF) number of ftm frames requested by initiator from target \n" \
"\t\t-y retry_cnt : (TOF) number of retransmit attempts for FTM frames \n" \
"\tExample: wl proxd_params 1 -c 36 -i 100 -d 10 -s -40 -p 12 -r 6 -t 20 -m 1000\n" \
"\tExample: wl proxd_params 1 -s -55\n" \
"\tExample: wl proxd_params 2 -c 11 -f 10 -g 00:90:4c:a5:01:32 -r v0"
#define PROXD_TUNE_USAGE \
"\tUsage: wl proxd_tune method [operations]\n\n" \
"\tMandatory args:\n" \
"\t\tmethod: == 2 (TOF) methods are supported \n\n" \
"\tOperations:\n" \
"\t\t-k K factor : hardware dependant RTD delay adjustment factor \n" \
"\t\t-b vhtack : 0:disable VHT ACK, 1:enable VHT ACK\n" \
"\t\t-n minDT : min time difference of T1 and T4 or T2 and T3 \n" \
"\t\t-x maxDT : max time difference of T1 and T4 or T2 and T3 \n" \
"\t\t-t total_frmcnt : total count limit of measurement frames transmitted \n" \
"\t\t-N threshold_log2 : log2 number of simple threshold crossing \n" \
"\t\t-S threshold_scale: scale number of simple threshold crossing \n" \
"\t\t-F ftm_cnt : number of measurement frames requested by initiator \n" \
"\t\t-r rsv_media_value: reserve media duration value for TOF \n" \
"\t\t-f flags : TOF state machine control flags\n" \
"\t\t-A timestamp_adj : enable/disable sw/hw/seq assisted timestamp adjustment, " \
"the data format is s[0|1]h[0|1]r[0|1] \n" \
"\t\t-W window_adjust : set search window length and offset, " \
"the data format is bBlLoO, B is bandwidth \n" \
"\t\t : with value 20, 40 or 80, L is window length, O is offset"
static cmd_t wl_proxd_cmds[] = {
{ "proxd", wl_proxd, WLC_GET_VAR, WLC_SET_VAR,
"Enable/Disable Proximity Detection\n"
"\t0 : disable\n"
"\t1 [initiator|target|neutral] [u/r]: enable with the specified mode and wakeup"
" mechanism\n"
"\tftm [<session-id>] <cmd> [<param-name><param-value>...]:"
" enable FTM, type 'wl proxd -h ftm' for more information\n\n"
"\tExample: wl proxd 1 initiator"},
{ "proxd_collect", wl_proxd_collect, WLC_GET_VAR, WLC_SET_VAR,
"collect the debugging informations of Proximity Detection \n\n"
"Optional parameters is:\n"
"\tenable to enable the proxd collection.\n"
"\tdisable to disable the proxd collection.\n"
"\t-l, dump local collect data and request load remote AP collect data.\n"
"\t-r, dump remote collect data or request load remote AP collect data.\n"
"\t-f File name to dump the sample buffer (default \"proxd_collect.dat\")\n"},
{ "proxd_params", wl_proxd_params, WLC_GET_VAR, WLC_SET_VAR,
"Set/Get operational parameters for a method of Proximity Detection\n\n"
PROXD_PARAMS_USAGE},
{ "proxd_tune", wl_proxd_tune, WLC_GET_VAR, WLC_SET_VAR,
"Set/Get tune parameters for TOF method of Proximity Detection\n\n"
PROXD_TUNE_USAGE},
{ "proxd_bssid", wl_iov_mac, WLC_GET_VAR, WLC_SET_VAR,
"Set/Get BSSID to be used in proximity detection frames\n\n"
"\tUsage: wl proxd_bssid <xx:xx:xx:xx:xx:xx>"},
{ "proxd_mcastaddr", wl_iov_mac, WLC_GET_VAR, WLC_SET_VAR,
"Set/Get Multicast MAC address of Proximity Detection Frames\n\n"
"\tUsage: wl proxd_mcastaddr <xx:xx:xx:xx:xx:xx>"},
{ "proxd_find", wl_var_void, -1, WLC_SET_VAR,
"Start Proximity Detection" },
{ "proxd_stop", wl_var_void, -1, WLC_SET_VAR,
"Stop Proximity Detection" },
{ "proxd_status", wl_proxd_status, WLC_GET_VAR, -1,
"Get status of Proximity Detection" },
{ "proxd_monitor", wl_iov_mac, -1, WLC_SET_VAR,
"Monitor detected peer status in proximity\n\n"
"\tUsage: wl proxd_monitor <xx:xx:xx:xx:xx:xx>"},
{ "proxd_payload", wl_proxd_payload, WLC_GET_VAR, WLC_SET_VAR,
"Get/Set payload content transferred between the proximity detected peers\n\n"
"\tUsage: wl proxd_payload [len hexstring]"},
{ "proxd_report", wl_proxd_report, WLC_GET_VAR, WLC_SET_VAR,
"Get/Set report distance results list\n\n"
"\tUsage: wl proxd_report [mac address list]"},
#if defined(WL_NAN)
{"proxd_nancfg", wl_nan_ranging_config, -1, -1,
"Get/Set \"proxd_nancfg\" params .\n"
"\tUsage: wl proxd_nancfg <chanspec> <start_timeslot> <duration> [<allow_mac> [flag]]\n"},
{"proxd_nanfind", wl_nan_ranging_start, -1, -1,
"Send specified \"proxd_nanfind \" params .\n"
"\tUsage: wl proxd_nanfind <num_dws> [<chanspec> <peer addr> <bitmap> "
"<count> <retry> <flag>]\n"
"\t\t for each peer, add the [<chanspec> <peer addr> <bitmap> <count> <retry> <flag>]\n"},
{"proxd_nanstatus", wl_nan_ranging_results_host, WLC_GET_VAR, -1,
"Return host initiated ranging results.\n"},
{"proxd_nanpeer", wl_nan_ranging_results_host, WLC_GET_VAR, -1,
"Return peer initiated ranging results.\n"},
#endif /* WL_NAN */
#if defined(linux)
{ "proxd_event_check", wl_proxd_event_check, -1, -1,
"Listen and print Location Based Service events\n"
"\tproxd_event_check syntax is: proxd_event_check ifname"},
#endif /* linux */
{ NULL, NULL, 0, 0, NULL }
};
static char *buf;
/*
* for FTM
*/
static int wl_proxd_cmd_method_handler(void *wl, cmd_t *cmd, char **argv);
static int ftm_handle_help(char **argv);
#if defined(linux)
static int ftm_event_check(bcm_event_t *p_bcm_event);
#endif
static void ftm_display_config_help();
static void ftm_display_config_options_help();
static void ftm_display_config_avail_help();
static void ftm_unpack_and_display_session_flags(const uint8 *p_data, uint16 tlvid);
static void ftm_unpack_and_display_config_flags(const uint8 *p_data, uint16 tlvid);
static int proxd_tune_display(wl_proxd_params_tof_tune_t *tof_tune, uint16 len);
/*
*for debug: define the flag WL_FTM_DEBUG to enable debug log for FTM
*/
/* #define WL_FTM_DEBUG */
#ifdef WL_FTM_DEBUG
static void ftm_format_event_mask(wl_proxd_event_type_t event, char *p_strbuf, int bufsize);
#endif /* WL_FTM_DEBUG */
/* module initialization */
void
wluc_proxd_module_init(void)
{
/* get the global buf */
buf = wl_get_buf();
/* register proxd commands */
wl_module_cmds_register(wl_proxd_cmds);
}
static int
wl_proxd(void *wl, cmd_t *cmd, char **argv)
{
uint16 var[2], *reply;
uint16 method = 0, role = 0;
void *ptr;
int ret;
/* skip the command name and check if NULL */
if (!*++argv) {
/* Get */
ret = wlu_var_getbuf(wl, cmd->name, &var, sizeof(var), &ptr);
if (ret != BCME_OK) {
return ret;
}
reply = (uint16 *)ptr;
method = dtoh16(reply[0]);
printf("%d\n", method);
if (method > 0) {
char c = 'u';
role = dtoh16(reply[1]);
if (role & WL_PROXD_RANDOM_WAKEUP) {
c = 'r';
role &= ~WL_PROXD_RANDOM_WAKEUP;
}
if (role == WL_PROXD_MODE_INITIATOR)
printf("%s %c\n", "initiator", c);
else if (role == WL_PROXD_MODE_TARGET)
printf("%s %c\n", "target", c);
else if (role == WL_PROXD_MODE_NEUTRAL)
printf("%s %c\n", "neutral", c);
}
} else {
/* Set */
if (!isdigit((int)*argv[0]))
return wl_proxd_cmd_method_handler(wl, cmd, argv);
/* parse method and role */
method = (uint16)atoi(argv[0]);
if (method > 0) {
if (!argv[1]) {
/* Default when it is not specified */
role = WL_PROXD_MODE_NEUTRAL | WL_PROXD_RANDOM_WAKEUP;
}
else {
if (stricmp(argv[1], "initiator") == 0)
role = WL_PROXD_MODE_INITIATOR;
else if (stricmp(argv[1], "target") == 0)
role = WL_PROXD_MODE_TARGET;
else if (stricmp(argv[1], "neutral") == 0) {
role = WL_PROXD_MODE_NEUTRAL;
role |= WL_PROXD_RANDOM_WAKEUP;
}
else
return BCME_USAGE_ERROR;
if (argv[2]) {
if (*argv[2] == 'R' || *argv[2] == 'r')
role |= WL_PROXD_RANDOM_WAKEUP;
else if (*argv[2] == 'u' || *argv[2] == 'U')
role &= ~WL_PROXD_RANDOM_WAKEUP;
}
}
}
var[0] = htod16(method);
var[1] = htod16(role);
ret = wlu_var_setbuf(wl, cmd->name, &var, sizeof(var));
}
return ret;
}
static int
wl_proxd_get_debug_data(void *wl, cmd_t *cmd, int index)
{
int ret;
void *buff;
wl_proxd_collect_query_t query;
wl_proxd_debug_data_t *replay;
bzero(&query, sizeof(query));
query.method = htol32(PROXD_TOF_METHOD);
query.request = PROXD_COLLECT_QUERY_DEBUG;
query.index = htol16(index);
ret = wlu_var_getbuf(wl, cmd->name, &query, sizeof(query), &buff);
if (ret != BCME_OK)
return ret;
replay = (wl_proxd_debug_data_t *)buff;
if (index == 0)
printf("\n/* Debug Informations */\n");
printf("%s[%u,%u]: type %u action(%u,%u) token(%u, %u)\n",
replay->received? "RX" : "TX",
replay->count, replay->stage,
replay->paket_type,
replay->category, replay->action,
replay->token, replay->follow_token);
if (replay->tof_cmd == 0 && replay->tof_rsp == 0) {
printf("\n");
return BCME_OK;
}
printf("Index=%d\n", ltoh16(replay->index));
printf("M_TOF_CMD=0x%04x\tM_TOF_RSP=0x%04x\tM_TOF_ID=0x%04x\n",
ltoh16(replay->tof_cmd), ltoh16(replay->tof_rsp), ltoh16(replay->tof_id));
printf("M_TOF_AVB_RX_L=0x%04x\tM_TOF_AVB_RX_H=0x%04x\t",
ltoh16(replay->tof_avb_rxl), ltoh16(replay->tof_avb_rxh));
printf("M_TOF_AVB_TX_L=0x%04x\tM_TOF_AVB_TX_H=0x%04x\n",
ltoh16(replay->tof_avb_txl), ltoh16(replay->tof_avb_txh));
printf("M_TOF_STATUS0=0x%04x\tM_TOF_STATUS2=0x%04x\t",
ltoh16(replay->tof_status0), ltoh16(replay->tof_status2));
printf("M_TOF_CHNSM_0=0x%04x\tM_TOF_CHNSM_1=0x%04x\n",
ltoh16(replay->tof_chsm0), 0);
printf("M_TOF_PHYCTL0=0x%04x\tM_TOF_PHYCTL1=0x%04x\tM_TOF_PHYCTL2=0x%04x\n",
ltoh16(replay->tof_phyctl0), ltoh16(replay->tof_phyctl1),
ltoh16(replay->tof_phyctl2));
printf("M_TOF_LSIG=0x%04x\tM_TOF_VHTA0=0x%04x\tM_TOF_VHTA1=0x%04x\n",
ltoh16(replay->tof_lsig), ltoh16(replay->tof_vhta0), ltoh16(replay->tof_vhta1));
printf("M_TOF_VHTA2=0x%04x\tM_TOF_VHTB0=0x%04x\tM_TOF_VHTB1=0x%04x\n",
ltoh16(replay->tof_vhta2), ltoh16(replay->tof_vhtb0), ltoh16(replay->tof_vhtb1));
printf("M_TOF_AMPDU_CTL=0x%04x\tM_TOF_AMPDU_DLIM=0x%04x\tM_TOF_AMPDU_LEN=0x%04x\n\n",
ltoh16(replay->tof_apmductl), ltoh16(replay->tof_apmdudlim),
ltoh16(replay->tof_apmdulen));
return BCME_OK;
}
static void
wlc_proxd_collec_header_dump(wl_proxd_collect_header_t *pHdr)
{
int i;
printf("total_frames %lu\n", (unsigned long)ltoh16(pHdr->total_frames));
printf("nfft %lu\n", (unsigned long)ltoh16(pHdr->nfft));
printf("bandwidth %lu\n", (unsigned long)ltoh16(pHdr->bandwidth));
printf("channel %lu\n", (unsigned long)ltoh16(pHdr->channel));
printf("chanspec %lu\n", (unsigned long)ltoh32(pHdr->chanspec));
printf("fpfactor %lu\n", (unsigned long)ltoh32(pHdr->fpfactor));
printf("fpfactor_shift %lu\n", (unsigned long)ltoh16(pHdr->fpfactor_shift));
printf("distance %li\n", (long)ltoh32(pHdr->distance));
printf("meanrtt %lu\n", (unsigned long)ltoh32(pHdr->meanrtt));
printf("modertt %lu\n", (unsigned long)ltoh32(pHdr->modertt));
printf("medianrtt %lu\n", (unsigned long)ltoh32(pHdr->medianrtt));
printf("sdrtt %lu\n", (unsigned long)ltoh32(pHdr->sdrtt));
printf("clkdivisor %lu\n", (unsigned long)ltoh32(pHdr->clkdivisor));
printf("chipnum %lu\n", (unsigned long)ltoh16(pHdr->chipnum));
printf("chiprev %lu\n", (unsigned long)pHdr->chiprev);
printf("phyver %lu\n", (unsigned long)pHdr->phyver);
printf("localMacAddr %s\n", wl_ether_etoa(&(pHdr->localMacAddr)));
printf("remoteMacAddr %s\n", wl_ether_etoa(&(pHdr->remoteMacAddr)));
printf("params_Ki %lu\n", (unsigned long)ltoh32(pHdr->params.Ki));
printf("params_Kt %lu\n", (unsigned long)ltoh32(pHdr->params.Kt));
printf("params_vhtack %li\n", (long)ltoh16(pHdr->params.vhtack));
printf("params_N_log2 %d\n", TOF_BW_NUM);
for (i = 0; i < TOF_BW_NUM; i++) {
printf("%li\n", (long)ltoh16(pHdr->params.N_log2[i]));
}
printf("params_N_scale %d\n", TOF_BW_NUM);
for (i = 0; i < TOF_BW_NUM; i++) {
printf("%li\n", (long)ltoh16(pHdr->params.N_scale[i]));
}
printf("params_sw_adj %lu\n", (unsigned long)pHdr->params.sw_adj);
printf("params_hw_adj %lu\n", (unsigned long)pHdr->params.hw_adj);
printf("params_seq_en %lu\n", (unsigned long)pHdr->params.seq_en);
printf("params_core %lu\n", (unsigned long)pHdr->params.core);
printf("params_N_log2_seq 2\n");
for (i = 0; i < 2; i++) {
printf("%li\n", (long)ltoh16(pHdr->params.N_log2[i + TOF_BW_NUM]));
}
printf("params_N_scale_seq 2\n");
for (i = 0; i < 2; i++) {
printf("%li\n", (long)ltoh16(pHdr->params.N_scale[i + TOF_BW_NUM]));
}
printf("params_w_offset %d\n", TOF_BW_NUM);
for (i = 0; i < TOF_BW_NUM; i++) {
printf("%li\n", (long)ltoh16(pHdr->params.w_offset[i]));
};
printf("params_w_len %d\n", TOF_BW_NUM);
for (i = 0; i < TOF_BW_NUM; i++) {
printf("%li\n", (long)ltoh16(pHdr->params.w_len[i]));
};
printf("params_maxDT %li\n", (long)ltoh32(pHdr->params.maxDT));
printf("params_minDT %li\n", (long)ltoh32(pHdr->params.minDT));
printf("params_totalfrmcnt %lu\n", (unsigned long)pHdr->params.totalfrmcnt);
printf("params_rsv_media %lu\n", (unsigned long)ltoh16(pHdr->params.rsv_media));
}
static int wlc_proxd_collect_data_check_ver_len(uint16 expected_ver,
uint16 ver, uint16 len)
{
int ret = BCME_OK;
switch (expected_ver) {
case WL_PROXD_COLLECT_DATA_VERSION_1:
/* v1 does not haver version and length fields */
ret = BCME_OK;
break;
case WL_PROXD_COLLECT_DATA_VERSION_2:
if ((ver != expected_ver) ||
(len != sizeof(wl_proxd_collect_data_t_v2) -
OFFSETOF(wl_proxd_collect_data_t_v2, len))) {
ret = BCME_VERSION;
}
break;
default:
ret = BCME_UNSUPPORTED;
}
return ret;
}
static int wlc_proxd_collec_data_dump(void *replay, FILE *fp,
wl_proxd_rssi_bias_avg_t *rssi_bias_avg, uint16 version)
{
int i, n, nbytes;
int ret = BCME_OK;
wl_proxd_collect_data_t_v1 *replay_v1 = NULL;
wl_proxd_collect_data_t_v2 *replay_v2 = NULL;
wl_proxd_collect_info_t *info = NULL;
uint32 *H = NULL;
uint32 *chan = NULL;
uint8 *ri_rr = NULL;
int nfft = 0;
#ifdef RSSI_REFINE
int rssi_dec = 0;
#else
/* rssi_bias_avg is unused under !RSSI_REFINE. */
/* Macro to prevent compiler warning under some platforms */
UNUSED_PARAMETER(rssi_bias_avg);
#endif
BCM_REFERENCE(H);
BCM_REFERENCE(chan);
BCM_REFERENCE(ri_rr);
/* Depending on version add the corresponding case and pointers to point
* to the correct member for use in the function
*/
switch (version) {
case WL_PROXD_COLLECT_DATA_VERSION_1:
replay_v1 = (wl_proxd_collect_data_t_v1 *)replay;
info = &replay_v1->info;
H = replay_v1->H;
ri_rr = replay_v1->ri_rr;
nbytes = sizeof(wl_proxd_collect_data_t_v1)
- (K_TOF_COLLECT_H_SIZE_20MHZ - nfft) * sizeof(uint32);
break;
case WL_PROXD_COLLECT_DATA_VERSION_2:
replay_v2 = (wl_proxd_collect_data_t_v2 *)replay;
ret = wlc_proxd_collect_data_check_ver_len(version, replay_v2->version,
replay_v2->len);
if (ret != BCME_OK) {
break;
}
info = &replay_v2->info;
H = replay_v2->H;
ri_rr = replay_v2->ri_rr;
chan = replay_v2->chan;
nbytes = sizeof(wl_proxd_collect_data_t_v2)
- (K_TOF_COLLECT_H_SIZE_20MHZ - nfft) * sizeof(uint32);
break;
default:
ret = BCME_VERSION;
break;
}
if (ret != BCME_OK) {
goto done;
}
if (info) {
nfft = (int)ltoh16(info->nfft);
#ifdef RSSI_REFINE
if (nfft > 0) {
printf("}\nImpulse Response = {\n");
for (i = 0; i < nfft; i++) {
printf("%010d ", ltoh32(info->rssi_bias.imp_resp[i]));
if ((i & 7) == 7)
printf("\n");
}
printf("RSSI_VERSION = %d\n", ltoh32(info->rssi_bias.version));
printf("PEAK_OFFSET = %d\n", ltoh32(info->rssi_bias.peak_offset));
rssi_bias_avg->avg_peak_offset += ltoh32(info->rssi_bias.peak_offset);
printf("PEAK_TO_AVG = %d", ltoh32(info->rssi_bias.bias));
rssi_bias_avg->avg_bias += ltoh32(info->rssi_bias.bias);
printf("\n");
for (i = 0; i < 10; i++) {
printf("THRESHOLD_%d = %u", i,
ltoh32(info->rssi_bias.threshold[i]));
if ((i+1) % 5)
printf(", ");
else
printf("\n");
rssi_bias_avg->avg_threshold[i] +=
ltoh32(info->rssi_bias.threshold[i]);
}
printf("SCALAR = %d", info->rssi_bias.threshold[10]);
}
/* convert tof_status2 from hex to dec */
rssi_dec = info->tof_rssi;
printf("\nRSSI10 = %d", rssi_dec);
rssi_bias_avg->avg_rssi += rssi_dec;
printf("\n\n");
#endif /* RSSI_REFINE */
/* printing the info portion */
printf("info_type %lu\n", (unsigned long)ltoh16(info->type));
printf("info_index %lu\n", (unsigned long)ltoh16(info->index));
printf("info_tof_cmd %lu\n", (unsigned long)ltoh16(info->tof_cmd));
printf("info_tof_rsp %lu\n", (unsigned long)ltoh16(info->tof_rsp));
printf("info_tof_avb_rxl %lu\n", (unsigned long)ltoh16(info->tof_avb_rxl));
printf("info_tof_avb_rxh %lu\n", (unsigned long)ltoh16(info->tof_avb_rxh));
printf("info_tof_avb_txl %lu\n", (unsigned long)ltoh16(info->tof_avb_txl));
printf("info_tof_avb_txh %lu\n", (unsigned long)ltoh16(info->tof_avb_txh));
printf("info_tof_id %lu\n", (unsigned long)ltoh16(info->tof_id));
printf("info_tof_frame_type %lu\n", (unsigned long)info->tof_frame_type);
printf("info_tof_frame_bw %lu\n", (unsigned long)info->tof_frame_bw);
printf("info_tof_rssi %li\n", (long)info->tof_rssi);
printf("info_tof_cfo %li\n", (long)ltoh32(info->tof_cfo));
printf("info_gd_adj_ns %li\n", (long)ltoh32(info->gd_adj_ns));
printf("info_gd_h_adj_ns %li\n", (long)ltoh32(info->gd_h_adj_ns));
printf("info_nfft %li\n", (long)ltoh16(info->nfft));
if (H) {
/* printing the H portion */
printf("H %d\n", nfft);
for (i = 0; i < nfft; i++) {
printf("%lu\n", (unsigned long)ltoh32(H[i]));
}
}
/* printing the chan and ri_rr */
if (info->index == 1) {
if (chan && version >= WL_PROXD_COLLECT_DATA_VERSION_2) {
n = (int)ltoh16((info->num_max_cores + 1)*
(K_TOF_COLLECT_CHAN_SIZE >> (2 - info->tof_frame_bw)));
printf("chan_est %d\n", n);
for (i = 0; i < n; i++) {
printf("%u\n", chan[i]);
}
}
if (ri_rr) {
printf("ri_rr %d\n", FTM_TPK_RI_RR_LEN);
for (i = 0; i < FTM_TPK_RI_RR_LEN; i++) {
printf("%u\n", ri_rr[i]);
}
}
}
ret = fwrite(replay, 1, nbytes, fp);
if (ret != nbytes) {
fprintf(stderr, "Error writing %d bytes to file, rc %d!\n",
nbytes, ret);
return BCME_ERROR;
}
}
done:
return ret;
}
static int
wl_proxd_get_collect_data(void *wl, cmd_t *cmd, FILE *fp, int index,
wl_proxd_rssi_bias_avg_t *rssi_bias_avg)
{
int ret;
void *buff;
wl_proxd_collect_query_t query;
uint16 expected_collect_data_ver = 0;
/* check firmware version */
/* Select collect data structure version based on FW version.
* Extend here for future versions
*/
if (wlc_ver_major(wl) <= 5) {
/* use v1 */
expected_collect_data_ver = WL_PROXD_COLLECT_DATA_VERSION_1;
} else {
/* use v2 */
expected_collect_data_ver = WL_PROXD_COLLECT_DATA_VERSION_2;
}
bzero(&query, sizeof(query));
query.method = htol32(PROXD_TOF_METHOD);
query.request = PROXD_COLLECT_QUERY_DATA;
query.index = htol16(index);
ret = wlu_var_getbuf(wl, cmd->name, &query, sizeof(query), &buff);
if (ret != BCME_OK)
return ret;
ret = wlc_proxd_collec_data_dump(buff, fp, rssi_bias_avg,
expected_collect_data_ver);
if (ret != BCME_OK) {
return ret;
}
return BCME_OK;
}
static int
wl_proxd_collect(void *wl, cmd_t *cmd, char **argv)
{
int ret;
void *buff;
wl_proxd_collect_query_t query, *pStatus;
wl_proxd_collect_header_t *pHdr;
const char *fname = "proxd_collect.dat";
FILE *fp = NULL;
int i, collect_method, total_frames, load_request = 0, remote_request = 0;
char chspec_str[CHANSPEC_STR_LEN];
chanspec_t chanspec;
float d_ref = -1;
#ifdef RSSI_REFINE
wl_proxd_rssi_bias_avg_t rssi_bias_avg;
bzero(&rssi_bias_avg, sizeof(rssi_bias_avg));
#endif
bzero(&query, sizeof(query));
query.method = htol32(PROXD_TOF_METHOD);
/* Skip the command name */
argv++;
while (*argv) {
if (strcmp(argv[0], "disable") == 0 || *argv[0] == '0') {
query.request = PROXD_COLLECT_SET_STATUS;
query.status = 0;
return wlu_var_getbuf(wl, cmd->name, &query, sizeof(query), &buff);
}
collect_method = (uint16)atoi(argv[0]);
if (strcmp(argv[0], "enable") == 0) {
query.request = PROXD_COLLECT_SET_STATUS;
query.status = 1;
return wlu_var_getbuf(wl, cmd->name, &query, sizeof(query), &buff);
} else if (isdigit((int)*argv[0]) &&
((collect_method >= WL_PROXD_COLLECT_METHOD_TYPE_DISABLE) &&
(collect_method <= WL_PROXD_COLLECT_METHOD_TYPE_EVENT_LOG))) {
query.request = PROXD_COLLECT_SET_STATUS;
query.status = collect_method;
return wlu_var_getbuf(wl, cmd->name, &query, sizeof(query), &buff);
}
if (!strcmp(argv[0], "-l")) {
load_request = 1;
argv++;
}
else if (!strcmp(argv[0], "-r")) {
remote_request = 1;
argv++;
}
else if (!strcmp(argv[0], "-f")) {
if (argv[1] == NULL)
return -1;
fname = argv[1];
argv += 2;
}
else if (!strcmp(argv[0], "-d")) {
if (argv[1] == NULL)
return -1;
sscanf((const char*)argv[1], "%f", &d_ref);
argv += 2;
} else
return -1;
}
query.request = PROXD_COLLECT_GET_STATUS;
ret = wlu_var_getbuf(wl, cmd->name, &query, sizeof(query), &buff);
if (ret != BCME_OK)
return ret;
pStatus = (wl_proxd_collect_query_t *)buff;
if (!pStatus->status) {
printf("Disable\n");
return BCME_OK;
}
if (pStatus->busy) {
printf("Busy\n");
return BCME_OK;
}
if ((pStatus->mode == WL_PROXD_MODE_TARGET) &&
(remote_request || load_request)) {
printf("Unsupport\n");
return BCME_OK;
}
if (remote_request && !pStatus->remote) {
printf("Remote data have not ready, please run this command again\n");
load_request = 1;
goto exit;
}
if (load_request && pStatus->remote) {
printf("Local data have not ready, please run command 'proxd_find' to get it\n");
goto exit;
}
query.request = PROXD_COLLECT_QUERY_HEADER;
ret = wlu_var_getbuf(wl, cmd->name, &query, sizeof(query), &buff);
if (ret != BCME_OK)
return ret;
pHdr = (wl_proxd_collect_header_t *)buff;
total_frames = (int)ltoh32(pHdr->total_frames);
if (!total_frames) {
printf("Enable\n");
goto exit;
}
chanspec = wl_chspec_from_driver(pHdr->chanspec);
wf_chspec_ntoa(chanspec, chspec_str);
printf("d_ref %5.1f\n", d_ref);
wlc_proxd_collec_header_dump(pHdr);
if ((fp = fopen(fname, "wb")) == NULL) {
fprintf(stderr, "Problem opening file %s\n", fname);
return 0;
}
ret = fwrite(buff, 1, sizeof(wl_proxd_collect_header_t), fp);
if (ret != sizeof(wl_proxd_collect_header_t)) {
fprintf(stderr, "Error writing to file rc %d\n", ret);
ret = -1;
goto exit;
}
for (i = 0; i < total_frames; i++) {
#ifdef RSSI_REFINE
ret = wl_proxd_get_collect_data(wl, cmd, fp, i, &rssi_bias_avg);
#else
ret = wl_proxd_get_collect_data(wl, cmd, fp, i, NULL);
#endif
if (ret != BCME_OK)
goto exit;
}
#ifdef RSSI_REFINE
if (total_frames > 0) {
printf("avg_rssi = %d avg_peak_offset = %d\n",
rssi_bias_avg.avg_rssi/total_frames,
rssi_bias_avg.avg_peak_offset/total_frames);
for (i = 0; i < 10; i++) {
printf("avg_threshold_%d = %d",
i, rssi_bias_avg.avg_threshold[i]/total_frames);
if ((i+1) % 5)
printf(", ");
else
printf("\n");
}
printf("avg_bias = %d\n", rssi_bias_avg.avg_bias/total_frames);
}
#endif
for (i = 0; i < 256; i++) {
ret = wl_proxd_get_debug_data(wl, cmd, i);
if (ret != BCME_OK)
break;
}
if (!load_request) {
/* FTM remote collect done */
query.request = PROXD_COLLECT_DONE;
(void)wlu_var_getbuf(wl, cmd->name, &query, sizeof(query), &buff);
}
ret = BCME_OK;
exit:
if (ret == BCME_OK && load_request) {
query.request = PROXD_COLLECT_REMOTE_REQUEST;
ret = wlu_var_getbuf(wl, cmd->name, &query, sizeof(query), &buff);
}
if (fp) fclose(fp);
return ret;
}
/* set measurement packet transmit rate */
static int proxd_method_set_vht_rate(miniopt_t *mopt)
{
char *startp, *endp;
char c;
bool legacy_set = FALSE, ht_set = FALSE, vht_set = FALSE;
int rate, mcs, Nss, tx_exp, bw, val;
bool stbc, ldpc, sgi;
uint32 rspec = 0;
/* set default values */
rate = 0;
mcs = 0;
Nss = 0;
tx_exp = 0;
stbc = FALSE;
ldpc = FALSE;
sgi = FALSE;
bw = 0;
startp = mopt->valstr;
endp = NULL;
if (*startp != 'h' && *startp != 'v') {
if ((rate = (int)strtol(startp, &endp, 10)) == 0)
return -1;
rate *= 2;
if (endp[0] == '.' && endp[1] == '5') {
rate += 1;
endp += 2;
}
startp = endp;
legacy_set = TRUE;
}
while (startp && ((c = *startp++) != '\0')) {
if (c == 'h') {
ht_set = TRUE;
mcs = (int)strtol(startp, &endp, 10);
if (mcs < 0 || mcs > 23) {
printf("HT MCS index %d out of range [0-23].\n", mcs);
return -1;
}
startp = endp;
}
else if (c == 'v') {
vht_set = TRUE;
mcs = (int)strtol(startp, &endp, 10);
if (mcs < 0 || mcs > 9) {
printf("HT MCS index %d out of range [0-9].\n", mcs);
return -1;
}
startp = endp;
}
else if (c == 'x') {
Nss = (int)strtol(startp, &endp, 10);
if (Nss < 1 || Nss > 8) {
printf("Nss %d out of range [1-8].\n", Nss);
return -1;
}
startp = endp;
}
else if (c == 'e') {
tx_exp = (int)strtol(startp, &endp, 10);
if (tx_exp < 0 || tx_exp > 3) {
printf("tx expansion %d out of range [0-3].\n", tx_exp);
return -1;
}
startp = endp;
}
else if (c == 's') {
stbc = TRUE;
continue;
}
else if (c == 'l') {
ldpc = TRUE;
continue;
}
else if (c == 'g') {
sgi = TRUE;
continue;
}
else if (c == 'b') {
val = (int)strtol(startp, &endp, 10);
if (val == 20) {
bw = WL_RSPEC_BW_20MHZ;
} else if (val == 40) {
bw = WL_RSPEC_BW_40MHZ;
} else if (val == 80) {
bw = WL_RSPEC_BW_80MHZ;
} else if (val == 160) {
bw = WL_RSPEC_BW_160MHZ;
} else {
printf("unexpected bandwidth specified \"%d\", "
"expected 20, 40, 80, or 160\n", val);
return -1;
}
startp = endp;
}
}
if (!legacy_set && !ht_set && !vht_set) {
printf("must specify one of legacy rate, HT (11n) rate hM, "
"or VHT (11ac) rate vM[xS]\n");
return -1;
}
if (legacy_set && (ht_set || vht_set)) {
printf("cannot use legacy rate and HT rate or VHT rate at the same time\n");
return -1;
}
if (ht_set && vht_set) {
printf("cannot use HT rate hM and HT rate vM[xS] at the same time\n");
return -1;
}
if (!vht_set && Nss != 0) {
printf("cannot use xS option with non VHT rate\n");
return -1;
}
if ((stbc || ldpc || sgi) && !(ht_set || vht_set)) {
printf("cannot use STBC/LDPC/SGI options with non HT/VHT rates\n");
return -1;
}
if (legacy_set) {
rspec = WL_RSPEC_ENCODE_RATE; /* 11abg */
rspec |= rate;
} else if (ht_set) {
rspec = WL_RSPEC_ENCODE_HT; /* 11n HT */
rspec |= mcs;
} else {
rspec = WL_RSPEC_ENCODE_VHT; /* 11ac VHT */
if (Nss == 0) {
Nss = 1; /* default Nss = 1 if --ss option not given */
}
rspec |= (Nss << WL_RSPEC_VHT_NSS_SHIFT) | mcs;
}
/* set the other rspec fields */
rspec |= (tx_exp << WL_RSPEC_TXEXP_SHIFT);
rspec |= bw;
rspec |= (stbc ? WL_RSPEC_STBC : 0);
rspec |= (ldpc ? WL_RSPEC_LDPC : 0);
rspec |= (sgi ? WL_RSPEC_SGI : 0);
mopt->uval = rspec;
return 0;
}
/* proxd set params common cmdl opts */
int proxd_method_set_common_param_from_opt(cmd_t *cmd,
miniopt_t *mopt, wl_proxd_params_common_t *proxd_params)
{
chanspec_t chanspec;
if (mopt->opt == 'c') {
/* chanspec iovar uses wl_chspec32_to_driver(chanspec), why ? */
if ((chanspec = wf_chspec_aton(mopt->valstr)) == 0) {
fprintf(stderr, "%s: could not parse \"%s\" as a channel\n",
cmd->name, mopt->valstr);
return BCME_BADARG;
}
proxd_params->chanspec
= wl_chspec_to_driver(chanspec);
if (proxd_params->chanspec == INVCHANSPEC) {
fprintf(stderr,
"%s: wl_chspec_to_driver() error \"%s\" \n",
cmd->name, mopt->valstr);
return BCME_BADARG;
}
} else if (mopt->opt == 't') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as a timeout\n",
cmd->name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_params->timeout = htod16(mopt->val);
}
else
return BCME_USAGE_ERROR;
return BCME_OK;
}
/* proxd TOF cmdl ops */
int proxd_method_tof_set_param_from_opt(cmd_t *cmd,
miniopt_t *mopt, wl_proxd_params_tof_method_t *proxd_params)
{
if (mopt->opt == 'g') {
/* this param is only valid for TOF method only */
struct ether_addr ea;
if (!wl_ether_atoe(mopt->valstr, &ea)) {
fprintf(stderr,
"%s: could not parse \"%s\" as MAC address\n",
cmd->name, mopt->valstr);
return BCME_USAGE_ERROR;
}
memcpy(&proxd_params->tgt_mac, &ea, 6);
} else if (mopt->opt == 'f') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as FTM frame count\n",
cmd->name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_params->ftm_cnt = htod16(mopt->val);
} else if (mopt->opt == 'y') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as Retry Count\n",
cmd->name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_params->retry_cnt = htod16(mopt->val);
} else if (mopt->opt == 'r') {
if (!mopt->good_int) {
/* special case check for "-r 5.5" */
if (!strcmp(mopt->valstr, "5.5")) {
mopt->uval = 11;
} else if (proxd_method_set_vht_rate(mopt)) {
fprintf(stderr,
"%s: could not parse \"%s\" as a rate\n",
cmd->name, mopt->valstr);
return BCME_USAGE_ERROR;
}
} else
mopt->uval = mopt->uval*2;
proxd_params->tx_rate = htod16((mopt->uval & 0xffff));
proxd_params->vht_rate = htod16((mopt->uval >> 16));
} else
return BCME_USAGE_ERROR;
return BCME_OK;
}
/* RSSI method specific mdl opts */
int proxd_method_rssi_set_param_from_opt(cmd_t *cmd,
miniopt_t *mopt, wl_proxd_params_rssi_method_t *proxd_params)
{
if (mopt->opt == 'i') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as an interval\n",
cmd->name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_params->interval = htod16(mopt->val);
} else if (mopt->opt == 'd') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as a duration\n",
cmd->name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_params->duration = htod16(mopt->val);
} else if (mopt->opt == 'p') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as a power\n",
cmd->name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_params->tx_power = htod16(mopt->val);
} else if (mopt->opt == 's') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as a RSSI\n",
cmd->name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_params->rssi_thresh = htod16(mopt->val);
} else if (mopt->opt == 'm') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as a maxconvergetime\n",
cmd->name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_params->maxconvergtmo = htod16(mopt->val);
} else if (mopt->opt == 'r') {
if (!mopt->good_int) {
/* special case check for "-r 5.5" */
if (!strcmp(mopt->valstr, "5.5")) {
mopt->val = 11;
} else {
fprintf(stderr,
"%s: could not parse \"%s\" as a rate\n",
cmd->name, mopt->valstr);
return BCME_USAGE_ERROR;
}
} else
mopt->val = mopt->val*2;
proxd_params->tx_rate = htod16(mopt->val);
}
else
return BCME_USAGE_ERROR;
return BCME_OK;
}
static int
wl_proxd_params(void *wl, cmd_t *cmd, char **argv)
{
wl_proxd_params_iovar_t proxd_params, *reply;
uint16 method;
void *ptr = NULL;
int ret, opt_err;
miniopt_t to;
char chspec_str[CHANSPEC_STR_LEN];
char rate_str[64];
chanspec_t chanspec;
uint16 interval, duration;
uint32 tx_rate;
/* skip the command name and check if mandatory exists */
if (!*++argv) {
fprintf(stderr, "missing mandatory parameter \'method\'\n");
return BCME_USAGE_ERROR;
}
/* parse method */
method = (uint16)atoi(argv[0]);
if (method == 0) {
fprintf(stderr, "invalid parameter \'method\'\n");
return BCME_USAGE_ERROR;
}
bzero(&proxd_params, sizeof(proxd_params));
/* set method to get/set */
proxd_params.method = htod16(method);
ret = wlu_var_getbuf_sm(wl, cmd->name, &proxd_params, sizeof(proxd_params), &ptr);
if (ret != BCME_OK) {
return ret;
}
if (!*++argv) {
/* get */
/* display proxd_params got */
reply = (wl_proxd_params_iovar_t *)ptr;
printf("bf proxd_params.method:%d\n", proxd_params.method);
switch (proxd_params.method) {
case PROXD_RSSI_METHOD:
chanspec = wl_chspec_from_driver(reply->u.rssi_params.chanspec);
tx_rate = dtoh16(reply->u.rssi_params.tx_rate);
wf_chspec_ntoa(chanspec, chspec_str);
printf("channel=%s\n", chspec_str);
printf("interval=%d TU\n", dtoh16(reply->u.rssi_params.interval));
printf("duration=%d ms\n", dtoh16(reply->u.rssi_params.duration));
printf("rssi_thresh=%d dBm\n",
(int16)dtoh16(reply->u.rssi_params.rssi_thresh));
printf("maxconvergetime=%d ms\n\n",
dtoh16(reply->u.rssi_params.maxconvergtmo));
printf("tx_power=%d dBm\n",
(int16)dtoh16(reply->u.rssi_params.tx_power));
printf("tx_rate=%d%s Mbps\n",
(tx_rate / 2), (tx_rate & 1) ? ".5" : "");
printf("timeout=%d ms\n", dtoh16(reply->u.rssi_params.timeout));
break;
case PROXD_TOF_METHOD:
chanspec = wl_chspec_from_driver(reply->u.tof_params.chanspec);
tx_rate = dtoh16(reply->u.tof_params.tx_rate) |
(dtoh16(reply->u.tof_params.vht_rate) << 16);
wf_chspec_ntoa(chanspec, chspec_str);
wl_rate_print(rate_str, tx_rate);
printf("tgt_mac=%s \n",
wl_ether_etoa(&reply->u.tof_params.tgt_mac));
printf("ftm_cnt= %d\n", dtoh16(reply->u.tof_params.ftm_cnt));
printf("channel=%s (0x%04x)\n", chspec_str, chanspec);
printf("tx_rate=%s (0x%08x)\n", rate_str, tx_rate);
printf("timeout=%d ms\n",
dtoh16(reply->u.tof_params.timeout));
printf("retry_cnt=%d \n", dtoh16(reply->u.tof_params.retry_cnt));
break;
default:
fprintf(stderr,
"%s: ERROR undefined method \n", cmd->name);
return BCME_BADARG;
}
} else { /* set */
memcpy((void *)&proxd_params, (void *)ptr, sizeof(proxd_params));
proxd_params.method = method;
/* set */
miniopt_init(&to, cmd->name, NULL, FALSE);
while ((opt_err = miniopt(&to, argv)) != -1) {
int com_res, meth_res;
if (opt_err == 1) {
return BCME_USAGE_ERROR;
}
argv += to.consumed;
/* process cmd opts common for all methods */
com_res = proxd_method_set_common_param_from_opt(cmd,
&to, &proxd_params.u.cmn_params);
/* method specific opts */
switch (method) {
case PROXD_RSSI_METHOD:
meth_res = proxd_method_rssi_set_param_from_opt(cmd,
&to, &proxd_params.u.rssi_params);
break;
case PROXD_TOF_METHOD:
meth_res = proxd_method_tof_set_param_from_opt(cmd,
&to, &proxd_params.u.tof_params);
if (meth_res == BCME_BADARG)
return meth_res;
break;
default:
printf("ERROR: unsupported method\n");
return BCME_USAGE_ERROR;
}
/* if option is unknown to both common and meth specific */
if ((com_res != BCME_OK) && (meth_res != BCME_OK)) {
printf(">>>> Method:%d doesn't support cmd option:'%c'\n",
method, to.opt);
return BCME_USAGE_ERROR;
}
}
/* Sanity check of parameters against each other */
interval = dtoh16(proxd_params.u.rssi_params.interval);
duration = dtoh16(proxd_params.u.rssi_params.duration);
if (interval < duration) {
fprintf(stderr,
"%s: \'interval\' cannot be shorter than \'duration\'\n",
cmd->name);
return BCME_BADARG;
}
ret = wlu_var_setbuf(wl, cmd->name, &proxd_params, sizeof(proxd_params));
}
return ret;
}
/* proxd parse mixed param: <str0><val0><str1><val1>... */
static void
proxd_method_tof_parse_mixed_param(char* str, const char** p_name, int* p_val, int* p_map)
{
char* p;
/* parse stuff of format <str0><val0><str1><val1>... */
while (*p_name) {
p = strstr((const char*)str, (const char*)*p_name);
if (p) {
p += strlen((const char*)*p_name);
*p_map = 1;
*p_val = strtol(p, NULL, 10);
} else {
*p_map = 0;
}
p_name++;
p_map++;
p_val++;
}
}
/* proxd TOF tune ops */
static int
proxd_tune_set_param_from_opt(const char* cmd_name,
miniopt_t *mopt, wl_proxd_params_tof_tune_t *proxd_tune)
{
if (mopt->opt == 'k') {
if (!mopt->good_int) {
char *p = strstr(mopt->valstr, ",");
if (p) {
proxd_tune->Ki = htod32(atoi(mopt->valstr));
proxd_tune->Kt = htod32(atoi(p+1));
}
else {
fprintf(stderr,
"%s: could not parse \"%s\" as K\n",
cmd_name, mopt->valstr);
return BCME_USAGE_ERROR;
}
}
else {
proxd_tune->Ki = htod32(mopt->val);
proxd_tune->Kt = htod32(mopt->val);
}
proxd_tune->setflags |= WL_PROXD_SETFLAG_K;
} else if (mopt->opt == 'b') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as vhtack\n",
cmd_name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->vhtack = htod16(mopt->val);
} else if (mopt->opt == 'c') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as core\n",
cmd_name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->core = htod16(mopt->val);
} else if (mopt->opt == 'A') {
const char* n[4] = {"s", "h", "r", NULL};
int v[3] = {0, 0, 0};
int m[3] = {0, 0, 0};
proxd_method_tof_parse_mixed_param(mopt->valstr, n, v, m);
if (m[TOF_ADJ_SOFTWARE]) {
/* sw adj */
proxd_tune->sw_adj = (int16)v[TOF_ADJ_SOFTWARE];
}
if (m[TOF_ADJ_HARDWARE]) {
/* hw adj */
proxd_tune->hw_adj = (int16)v[TOF_ADJ_HARDWARE];
}
if (m[TOF_ADJ_SEQ]) {
/* ranging sequence */
proxd_tune->seq_en = (int16)v[TOF_ADJ_SEQ];
}
if ((m[TOF_ADJ_SOFTWARE] | m[TOF_ADJ_HARDWARE] | m[TOF_ADJ_SEQ]) == 0) {
fprintf(stderr,
"%s: could not parse \"%s\" as hw/sw adjustment enable params\n",
cmd_name, mopt->valstr);
return BCME_USAGE_ERROR;
}
} else if (mopt->opt == 'n') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as min time difference limitation\n",
cmd_name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->minDT = htod32(mopt->val);
} else if (mopt->opt == 'x') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as max time difference limitation\n",
cmd_name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->maxDT = htod32(mopt->val);
} else if (mopt->opt == 'N') {
int i = 0;
if (!mopt->good_int) {
char *p = mopt->valstr;
while (p && i < TOF_BW_SEQ_NUM) {
if (htod16(atoi(p)))
proxd_tune->N_log2[i] = htod16(atoi(p));
i++;
p = strstr(p, ",");
if (p)
p++;
}
if (p) {
proxd_tune->N_log2_2g = htod16(atoi(p));
p = strstr(p, ",");
if (p)
p++;
}
if (p) {
proxd_tune->seq_5g20.N_tx_log2 = htod16(atoi(p));
p = strstr(p, ",");
if (p)
p++;
}
if (p) {
proxd_tune->seq_5g20.N_rx_log2 = htod16(atoi(p));
p = strstr(p, ",");
if (p)
p++;
}
if (p) {
proxd_tune->seq_2g20.N_tx_log2 = htod16(atoi(p));
p = strstr(p, ",");
if (p)
p++;
}
if (p) {
proxd_tune->seq_2g20.N_rx_log2 = htod16(atoi(p));
}
} else {
for (; i < TOF_BW_SEQ_NUM; i++) {
proxd_tune->N_log2[i] = htod16(mopt->val);
}
proxd_tune->N_log2_2g = htod16(mopt->val);
proxd_tune->seq_5g20.N_tx_log2 = htod16(mopt->val);
proxd_tune->seq_5g20.N_rx_log2 = htod16(mopt->val);
proxd_tune->seq_2g20.N_tx_log2 = htod16(mopt->val);
proxd_tune->seq_2g20.N_rx_log2 = htod16(mopt->val);
}
proxd_tune->setflags |= WL_PROXD_SETFLAG_N;
} else if (mopt->opt == 'S') {
int i = 0;
if (!mopt->good_int) {
char *p = mopt->valstr;
while (p && i < TOF_BW_SEQ_NUM) {
if (htod16(atoi(p)))
proxd_tune->N_scale[i] = htod16(atoi(p));
i++;
p = strstr(p, ",");
if (p)
p++;
}
if (p) {
proxd_tune->N_scale_2g = htod16(atoi(p));
p = strstr(p, ",");
if (p)
p++;
}
if (p) {
proxd_tune->seq_5g20.N_tx_scale = htod16(atoi(p));
p = strstr(p, ",");
if (p)
p++;
}
if (p) {
proxd_tune->seq_5g20.N_rx_scale = htod16(atoi(p));
p = strstr(p, ",");
if (p)
p++;
}
if (p) {
proxd_tune->seq_2g20.N_tx_scale = htod16(atoi(p));
p = strstr(p, ",");
if (p)
p++;
}
if (p) {
proxd_tune->seq_2g20.N_rx_scale = htod16(atoi(p));
}
} else {
for (; i < TOF_BW_SEQ_NUM; i++) {
proxd_tune->N_scale[i] = htod16(mopt->val);
}
proxd_tune->N_scale_2g = htod16(mopt->val);
proxd_tune->seq_5g20.N_tx_scale = htod16(mopt->val);
proxd_tune->seq_5g20.N_rx_scale = htod16(mopt->val);
proxd_tune->seq_2g20.N_rx_scale = htod16(mopt->val);
proxd_tune->seq_2g20.N_rx_scale = htod16(mopt->val);
}
proxd_tune->setflags |= WL_PROXD_SETFLAG_S;
} else if (mopt->opt == 'F') {
int i = 0;
if (!mopt->good_int) {
char *p = mopt->valstr;
while (p && i < TOF_BW_SEQ_NUM) {
if (htod16(atoi(p)))
proxd_tune->ftm_cnt[i] = htod16(atoi(p));
i++;
p = strstr(p, ",");
if (p)
p++;
}
} else {
for (; i < TOF_BW_SEQ_NUM; i++) {
proxd_tune->ftm_cnt[i] = htod16(mopt->val);
}
}
} else if (mopt->opt == 't') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as total frmcnt\n",
cmd_name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->totalfrmcnt = (mopt->val);
} else if (mopt->opt == 'r') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as media reserve value\n",
cmd_name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->rsv_media = (mopt->val);
} else if (mopt->opt == 'f') {
if (!mopt->good_int) {
fprintf(stderr,
"%s: could not parse \"%s\" as flags\n",
cmd_name, mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->flags = htod16(mopt->val);
} else if (mopt->opt == 'W') {
const char* n[4] = {"b", "l", "o", NULL};
const char* s[4] = {"s", "l", "o", NULL};
const char **p;
int v[TOF_BW_NUM] = {0, 0, 0};
int m[TOF_BW_NUM] = {0, 0, 0};
int i;
if (*mopt->valstr == 's')
p = s;
else
p = n;
proxd_method_tof_parse_mixed_param(mopt->valstr, p, v, m);
if (m[0]) {
/* Got bw */
if (v[0] == TOF_BW_80MHZ)
i = TOF_BW_80MHZ_INDEX;
else if (v[0] == TOF_BW_40MHZ)
i = TOF_BW_40MHZ_INDEX;
else if (v[0] == TOF_BW_20MHZ)
i = TOF_BW_20MHZ_INDEX;
else {
fprintf(stderr,
"%s: could not parse \"%s\" as window params\n",
cmd_name, mopt->valstr);
return BCME_USAGE_ERROR;
}
if (p == n) {
/* Normal */
if (m[1]) {
/* Got length */
proxd_tune->w_len[i] = (int16)v[1];
}
if (m[2]) {
/* Got offset */
proxd_tune->w_offset[i] = (int16)v[2];
}
} else {
/* Seq */
if (m[1] && i == TOF_BW_20MHZ_INDEX) {
/* Got length */
proxd_tune->seq_5g20.w_len = (int16)v[1];
proxd_tune->seq_2g20.w_len = (int16)v[1];
}
if (m[2]&& i == TOF_BW_20MHZ_INDEX) {
/* Got offset */
proxd_tune->seq_5g20.w_offset = (int16)v[2];
proxd_tune->seq_2g20.w_offset = (int16)v[2];
}
}
}
} else if (mopt->opt == 'B') {
if (!mopt->good_int) {
fprintf(stderr,
"proxd ftm tune: could not parse \"%s\" as bitflip_threshold\n",
mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->bitflip_thresh = htod16(mopt->val);
} else if (mopt->opt == 'R') {
if (!mopt->good_int) {
fprintf(stderr,
"proxd ftm tune: could not parse \"%s\" as snr_threshold\n",
mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->snr_thresh = htod16(mopt->val);
} else if (mopt->opt == 'T') {
if (!mopt->good_int) {
fprintf(stderr,
"proxd ftm tune: could not parse \"%s\" as recv_2g_threshold\n",
mopt->valstr);
return BCME_USAGE_ERROR;
}
if (mopt->val >= 0)
return BCME_RANGE;
proxd_tune->recv_2g_thresh = mopt->val;
} else if (mopt->opt == 'V') {
if (!mopt->good_int) {
fprintf(stderr,
"proxd ftm tune: could not parse \"%s\" as Auto Core Select "
"Group Delay Variance threshold\n",
mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->acs_gdv_thresh = htod32(mopt->val);
} else if (mopt->opt == 'I') {
if (!mopt->good_int) {
fprintf(stderr,
"proxd ftm tune: could not parse \"%s\" as Auto Core Select "
"RSSI threshold\n",
mopt->valstr);
return BCME_USAGE_ERROR;
}
if (mopt->val >= 0)
return BCME_RANGE;
proxd_tune->acs_rssi_thresh = mopt->val;
} else if (mopt->opt == 's') {
if (!mopt->good_int) {
fprintf(stderr,
"proxd ftm tune: could not parse \"%s\" as smoothing window "
"enable\n",
mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->smooth_win_en = mopt->val;
} else if (mopt->opt == 'M') {
if (!mopt->good_int) {
fprintf(stderr,
"proxd ftm tune: could not parse \"%s\" as auto core select "
"group delay max - min threshold\n",
mopt->valstr);
return BCME_USAGE_ERROR;
}
proxd_tune->acs_gdmm_thresh = htod32(mopt->val);
} else
return BCME_USAGE_ERROR;
return BCME_OK;
}
static int
wl_proxd_tune(void *wl, cmd_t *cmd, char **argv)
{
wl_proxd_params_iovar_t proxd_tune, *reply;
uint16 method;
void *ptr = NULL;
int ret, opt_err;
miniopt_t to;
/* skip the command name and check if mandatory exists */
if (!*++argv) {
fprintf(stderr, "missing mandatory parameter \'method\'\n");
return BCME_USAGE_ERROR;
}
/* parse method */
method = (uint16)atoi(argv[0]);
if (method == 0) {
fprintf(stderr, "invalid parameter \'method\'\n");
return BCME_USAGE_ERROR;
}
bzero(&proxd_tune, sizeof(proxd_tune));
proxd_tune.method = htod16(method);
ret = wlu_var_getbuf_sm(wl, cmd->name, &proxd_tune, sizeof(proxd_tune), &ptr);
if (ret != BCME_OK) {
return ret;
}
if (!*++argv) {
/* get */
/* display proxd_params got */
reply = (wl_proxd_params_iovar_t *)ptr;
printf("bf proxd_params.method:%d\n", proxd_tune.method);
switch (proxd_tune.method) {
case PROXD_RSSI_METHOD:
break;
case PROXD_TOF_METHOD:
ret = proxd_tune_display(&reply->u.tof_tune, sizeof(reply->u.tof_tune));
break;
default:
fprintf(stderr,
"%s: ERROR undefined method \n", cmd->name);
return BCME_BADARG;
}
} else {
/* set */
memcpy((void *)&proxd_tune, (void *)ptr, sizeof(proxd_tune));
proxd_tune.method = method;
miniopt_init(&to, cmd->name, NULL, FALSE);
while ((opt_err = miniopt(&to, argv)) != -1) {
int meth_res = BCME_USAGE_ERROR;
if (opt_err == 1) {
return BCME_USAGE_ERROR;
}
argv += to.consumed;
/* method specific opts */
switch (method) {
case PROXD_RSSI_METHOD:
break;
case PROXD_TOF_METHOD:
meth_res = proxd_tune_set_param_from_opt(cmd->name,
&to, &proxd_tune.u.tof_tune);
break;
default:
printf("ERROR: unsupported method\n");
return BCME_USAGE_ERROR;
}
/* if option is unknown to tune specific */
if (meth_res != BCME_OK) {
printf(">>>> Method:%d doesn't support cmd option:'%c'\n",
method, to.opt);
return meth_res;
}
}
ret = wlu_var_setbuf(wl, cmd->name, &proxd_tune, sizeof(proxd_tune));
}
return ret;
}
static const char *wl_proxd_mode_str(uint8 mode)
{
static const char *proxd_mode[] = {"Undetected", "Neutral", "Initiator", "Target",
"UNKNOWN"};
if (mode > WL_PROXD_MODE_TARGET)
mode = WL_PROXD_MODE_TARGET+1;
return proxd_mode[mode];
}
static const char *wl_proxd_state_str(uint8 state)
{
static const char *proxd_state[] = {"Poll", "Pairing", "Handshake", "Detected",
"Pipeline", "NegMode", "Monitor", "Unknown"};
if (state == RSSI_STATE_POLL)
return proxd_state[0];
if (state == RSSI_STATE_TPAIRING || state == RSSI_STATE_IPAIRING)
return proxd_state[1];
if (state == RSSI_STATE_THANDSHAKE || state == RSSI_STATE_IHANDSHAKE)
return proxd_state[2];
if (state == RSSI_STATE_CONFIRMED)
return proxd_state[3];
if (state == RSSI_STATE_PIPELINE)
return proxd_state[4];
if (state == RSSI_STATE_NEGMODE)
return proxd_state[5];
if (state == RSSI_STATE_MONITOR)
return proxd_state[6];
return proxd_state[7];
}
static const char *wl_proxd_tof_state_str(uint8 state)
{
static const char *tof_proxd_state[] =
{"Idle", "Wait", "LegacyWait", "Confirmed", "Unknown", "Report"};
if (state == TOF_STATE_IDLE)
return tof_proxd_state[0];
if (state == TOF_STATE_IWAITM || state == TOF_STATE_TWAITM ||
state == TOF_STATE_IWAITCL || state == TOF_STATE_TWAITCL)
return tof_proxd_state[1];
if (state == TOF_STATE_ILEGACY)
return tof_proxd_state[2];
if (state == TOF_STATE_ICONFIRM)
return tof_proxd_state[3];
if (state == TOF_STATE_IREPORT)
return tof_proxd_state[5];
return tof_proxd_state[4];
}
static const char *wl_proxd_tof_reason_str(uint8 reason)
{
static const char *tof_proxd_reason[] = {"OK", "RxedReqEnd", "Timeout",
"LostACK", "InvalidAVB"};
if (reason > TOF_REASON_INVALIDAVB)
reason = 0;
return tof_proxd_reason[reason];
}
static const char *wl_proxd_reason_str(uint8 reason)
{
static const char *proxd_reason[] = {"Unknown", "Low rssi", "State machine out of SYNC",
"Timeout"};
if (reason > RSSI_REASON_TIMEOUT)
reason = 0;
return proxd_reason[reason];
}
static int
wl_proxd_status(void *wl, cmd_t *cmd, char **argv)
{
wl_proxd_status_iovar_t status, *statusp;
int ret = BCME_BADARG;
if (!*++argv) {
/* Get */
bzero(&status, sizeof(wl_proxd_status_iovar_t));
if ((ret = wlu_iovar_get(wl, cmd->name, (void *) &status,
(sizeof(wl_proxd_status_iovar_t)))) < 0)
return (ret);
statusp = &status;
switch (statusp->method)
{
case PROXD_RSSI_METHOD:
printf("mode=%s\n", wl_proxd_mode_str(statusp->mode));
printf("state=%s\n", wl_proxd_state_str(statusp->state));
printf("peer mode=%s\n", wl_proxd_mode_str(statusp->peermode));
printf("peer=%s\n", wl_ether_etoa(&statusp->peer));
printf("lowest rssi=%d\n", statusp->low_rssi);
printf("highest rssi=%d\n", statusp->hi_rssi);
printf("tx pkts=%d\n", statusp->txcnt);
printf("rx pkts=%d\n", statusp->rxcnt);
printf("reason=%s\n\n", wl_proxd_reason_str(statusp->reason));
break;
case PROXD_TOF_METHOD:
printf("mode=%s\n", wl_proxd_mode_str(statusp->mode));
printf("state=%s\n", wl_proxd_tof_state_str(statusp->state));
if (statusp->distance == 0xffffffff)
printf("distance=-1\n");
else
printf("distance=%d.%04d\n", statusp->distance >> 4,
((statusp->distance & 0xf)*625));
printf("peer=%s\n", wl_ether_etoa(&statusp->peer));
printf("avg rssi=%d\n", statusp->avg_rssi);
printf("tx pkts=%d\n", statusp->txcnt);
printf("rx pkts=%d\n", statusp->rxcnt);
printf("frame types = CCK %d OFDM %d 11N %d 11AC %d\n",
statusp->frame_type_cnt[FRAME_TYPE_CCK],
statusp->frame_type_cnt[FRAME_TYPE_OFDM],
statusp->frame_type_cnt[FRAME_TYPE_11N],
statusp->frame_type_cnt[FRAME_TYPE_11AC]);
printf("adj types = SW %d HW %d SEQ %d NONE %d\n",
statusp->adj_type_cnt[TOF_ADJ_SOFTWARE],
statusp->adj_type_cnt[TOF_ADJ_HARDWARE],
statusp->adj_type_cnt[TOF_ADJ_SEQ],
statusp->adj_type_cnt[TOF_ADJ_NONE]);
printf("report status= %d\n", statusp->dbgstatus);
printf("reason=%s\n", wl_proxd_tof_reason_str(statusp->reason));
printf("frmcnt=%d\n", statusp->low_rssi);
if (statusp->hi_rssi == TOF_LEGACY_AP)
printf("measure=OneSide\n\n");
else
printf("measure=TwoSide\n\n");
break;
default:
printf("ERROR: unsupported method\n");
return BCME_USAGE_ERROR;
}
}
else
printf("Cannot set proxd_status\n");
return ret;
}
static int
wl_proxd_payload(void *wl, cmd_t *cmd, char **argv)
{
char *buf;
uint16 len, *reply;
int ret;
buf = malloc(WL_PROXD_PAYLOAD_LEN);
if (buf == NULL) {
fprintf(stderr, "Failed to allocate buffer of %d bytes\n", WL_PROXD_PAYLOAD_LEN);
return -1;
}
bzero(buf, WL_PROXD_PAYLOAD_LEN);
/* skip the command name and check if NULL */
if (!*++argv) {
/* Get */
if ((ret = wlu_iovar_get(wl, cmd->name, (void *)buf, WL_PROXD_PAYLOAD_LEN)) < 0) {
free(buf);
return (ret);
}
reply = (uint16 *)buf;
len = dtoh16(reply[0]);
if (len > 0) {
char *ptr = buf+sizeof(uint16);
char *endptr = ptr+len;
int num = 0;
uint8 val;
printf("Payload Length %d\n", len);
while (ptr < endptr)
{
val = *(uint8 *)ptr++;
printf("%02X", val);
if (++num == 40)
{
printf("\n");
num = 0;
}
}
if (num) printf("\n");
}
} else {
/* Set */
len = (uint16)atoi(argv[0]);
if (len > 0) {
if (!argv[1]) {
printf("Payload content is missing\n");
free(buf);
return -1;
}
else {
char *ptr = argv[1];
char *bufp = buf;
char hex[] = "XX";
if ((uint16)strlen(ptr) != len*2)
{
printf("Payload length mismatch %d %d\n", len,
((int)strlen(ptr))/2);
free(buf);
return -1;
}
while (*ptr) {
strncpy(hex, ptr, 2);
*bufp++ = (char) strtoul(hex, NULL, 16);
ptr += 2;
}
}
}
ret = wlu_var_setbuf(wl, cmd->name, buf, len);
}
free(buf);
return ret;
}
static int wl_proxd_report(void *wl, cmd_t *cmd, char **argv)
{
uint16 len;
int i, ret;
struct ether_addr addrlist[WL_PROXD_MAXREPORT];
/* skip the command name and check if NULL */
if (!*++argv) {
/* Get */
len = sizeof(struct ether_addr) * WL_PROXD_MAXREPORT;
bzero(&addrlist[0], len);
if ((ret = wlu_iovar_get(wl, cmd->name, (void *)addrlist, len)) < 0) {
return (ret);
}
for (i = 0; i < WL_PROXD_MAXREPORT; i++)
{
if (ETHER_ISNULLADDR(&addrlist[i]))
break;
printf("%s ", wl_ether_etoa(&addrlist[i]));
}
printf("\n");
} else {
/* Set */
i = 0;
while (argv[0]) {
if (i >= WL_PROXD_MAXREPORT) {
printf("Over the maxium report number %d\n", WL_PROXD_MAXREPORT);
return BCME_BUFTOOLONG;
}
if (!wl_ether_atoe(argv[0], &addrlist[i])) {
if (i == 0)
return BCME_BADADDR;
break;
}
i++;
argv++;
}
ret = wlu_var_setbuf(wl, cmd->name, addrlist, ETHER_ADDR_LEN * i);
}
return ret;
}
/* print or calculate & print location info */
void wl_proxd_tof_host_calc(wl_proxd_event_data_t* evp)
{
uint32 distance;
uint32 meanrtt, modertt, medianrtt, dst_sigma; /* standard deviation */
int ftm_cnt;
int16 avg_rssi, validfrmcnt;
int32 var1, var2, var3;
char diststr[40];
distance = ntoh32(evp->distance);
dst_sigma = ntoh32(evp->sdrtt);
ftm_cnt = ntoh16(evp->ftm_cnt);
avg_rssi = ntoh16(evp->avg_rssi);
validfrmcnt = ntoh16(evp->validfrmcnt);
meanrtt = ntoh32(evp->meanrtt);
modertt = ntoh32(evp->modertt);
medianrtt = ntoh32(evp->medianrtt);
var1 = ntoh32(evp->var1);
var2 = ntoh32(evp->var2);
var3 = ntoh32(evp->var3);
bzero(diststr, sizeof(diststr));
if (distance == 0xffffffff)
sprintf(diststr, "distance=-1m\n");
else
sprintf(diststr, "distance=%d.%04dm\n", distance>>4, (distance & 0xf) * 625);
if (ntoh16(evp->mode) == WL_PROXD_MODE_TARGET) {
if (evp->TOF_type == TOF_TYPE_REPORT) {
printf("Report:(%s) and ", wl_ether_etoa(&evp->peer_mac));
printf("(%s); %s", wl_ether_etoa((struct ether_addr *)
&evp->peer_router_info), diststr);
}
else
printf("Target:(%s); %s; ", wl_ether_etoa(&evp->peer_mac), diststr);
printf("mean %d mode %d median %d\n", meanrtt, modertt, medianrtt);
}
else
printf("Initiator:(%s); %s; ", wl_ether_etoa(&evp->peer_mac), diststr);
printf("sigma:%d.%d;", dst_sigma/10, dst_sigma % 10);
printf("rssi:%d validfrmcnt %d\n", avg_rssi, validfrmcnt);
if (evp->TOF_type == TOF_TYPE_REPORT)
printf("var3: %d\n", var3);
else
printf("var: %d %d %d\n", var1, var2, var3);
if (ftm_cnt > 1) {
int i;
printf("event contains %d rtd samples for host side calculation:\n",
ftm_cnt);
for (i = 0; i < ftm_cnt; i++) {
printf("ftm[%d] --> value:%d rssi:%d\n", i,
ntoh32(evp->ftm_buff[i].value), evp->ftm_buff[i].rssi);
}
printf("host side calculation result: TBD\n");
/* TODO: process raw samples */
/* e.g:
1) mean Mn = (S1+S2+... Sn)/N
2) variatin: Xn = (Sn - M)^2;
3) sqrt((X1 + X2 + .. Xn)/N)
*/
}
}
#ifdef WL_NAN
static const char *wl_proxd_nan_status_str(uint8 status)
{
static const char *proxd_nan_status[] = {"Unknown", "Success", "Fail", "Timeout", "Abort"};
if (status > WL_NAN_RANGING_STATUS_ABORT)
status = 0;
return proxd_nan_status[status];
}
/* print or calculate & print nan event */
void wl_proxd_nan_host_calc(wl_nan_ranging_event_data_t* evp)
{
wl_nan_ranging_result_t *rp;
int i;
uint32 distance;
uint32 dst_sigma; /* standard deviation */
uint8 validfrmcnt;
char dist[40];
rp = evp->rr;
for (i = 0; i < evp->count; i++, rp++) {
distance = rp->distance;
dst_sigma = rp->rtt_var;
validfrmcnt = rp->sounding_count;
bzero(dist, sizeof(dist));
if (distance == 0xffffffff)
sprintf(dist, "distance=-1m\n");
else
sprintf(dist, "distance=%d.%dm\n", distance>>4, (distance & 0xf)*625);
if (evp->mode == WL_PROXD_MODE_TARGET) {
if (!ETHER_ISNULLADDR(&rp->tgtea)) {
printf("Report:(%s) and ", wl_ether_etoa(&rp->ea));
printf("(%s); %s", wl_ether_etoa(&rp->tgtea), dist);
}
else
printf("Target:(%s); %s; ", wl_ether_etoa(&rp->ea), dist);
}
else
printf("Initiator:(%s); %s", wl_ether_etoa(&rp->ea), dist);
printf("%s sigma:%d.%d validfrmcnt %d\n", wl_proxd_nan_status_str(rp->status),
dst_sigma/10, dst_sigma % 10, validfrmcnt);
}
}
#endif /* WL_NAN */
#if defined(linux)
/* print timestamp info */
static void wl_proxd_tof_ts_results(wl_proxd_event_ts_results_t* tsp)
{
int16 ver;
int tscnt;
int i;
ver = ntoh16(tsp->ver);
tscnt = ntoh16(tsp->ts_cnt);
if (ver == 2) {
printf("Frame Count %d\n Timestamps:\n", tscnt);
if (tscnt > 0) {
for (i = 0; i < tscnt; i++) {
printf("t1[%d]=%u : t2[%d]=%u : t3[%d]=%u : t4[%d]=%u\n",
i, ntoh32(tsp->ts_buff[i].t1),
i, ntoh32(tsp->ts_buff[i].t2),
i, ntoh32(tsp->ts_buff[i].t3),
i, ntoh32(tsp->ts_buff[i].t4));
}
}
}
}
#define PROXD_EVENTS_BUFFER_SIZE 2048
static int
wl_proxd_event_check(void *wl, cmd_t *cmd, char **argv)
{
bool exit_on1stresult = FALSE;
int fd, err, octets;
struct sockaddr_ll sll;
struct ifreq ifr;
char ifnames[IFNAMSIZ] = {"eth0"};
bcm_event_t *event;
uint32 reason;
uint16 mode; /* target or initiator */
char* data;
int event_type;
uint8 event_inds_mask[WL_EVENTING_MASK_LEN]; /* 128-bit mask */
wl_proxd_event_data_t* evp = NULL;
#ifdef WL_NAN
wl_nan_ranging_event_data_t *nanevp = NULL;
#endif
wl_proxd_event_ts_results_t* tsp = NULL;
UNUSED_PARAMETER(wl);
UNUSED_PARAMETER(cmd);
if (argv[1] == NULL) {
printf("<ifname> param is missing\n");
return -1;
}
if (*++argv) {
strncpy(ifnames, *argv, (IFNAMSIZ - 1));
}
bzero(&ifr, sizeof(ifr));
strncpy(ifr.ifr_name, ifnames, (IFNAMSIZ - 1));
/* read current mask state */
if ((err = wlu_iovar_get(wl, "event_msgs", &event_inds_mask, WL_EVENTING_MASK_LEN))) {
printf("couldn't read event_msgs\n");
return (err);
}
event_inds_mask[WLC_E_PROXD / 8] |= 1 << (WLC_E_PROXD % 8);
if ((err = wlu_iovar_set(wl, "event_msgs", &event_inds_mask, WL_EVENTING_MASK_LEN)))
return (err);
if (*++argv) {
if (strcmp(*argv, "osh") == 0) {
/* exit after processing 1st proximity result */;
exit_on1stresult = TRUE;
}
}
fd = socket(PF_PACKET, SOCK_RAW, hton16(ETHER_TYPE_BRCM));
if (fd < 0) {
printf("Cannot create socket %d\n", fd);
return -1;
}
err = ioctl(fd, SIOCGIFINDEX, &ifr);
if (err < 0) {
printf("Cannot get iface:%s index \n", ifr.ifr_name);
goto exit1;
}
bzero(&sll, sizeof(sll));
sll.sll_family = AF_PACKET;
sll.sll_protocol = hton16(ETHER_TYPE_BRCM);
sll.sll_ifindex = ifr.ifr_ifindex;
err = bind(fd, (struct sockaddr *)&sll, sizeof(sll));
if (err < 0) {
printf("Cannot bind %d\n", err);
goto exit1;
}
data = (char*)malloc(PROXD_EVENTS_BUFFER_SIZE);
if (data == NULL) {
printf("Cannot not allocate %d bytes for events receive buffer\n",
PROXD_EVENTS_BUFFER_SIZE);
goto exit1;
}
printf("waiting for LBS events :%s\n", ifr.ifr_name);
while (1) {
fflush(stdout);
octets = recv(fd, data, PROXD_EVENTS_BUFFER_SIZE, 0);
if (octets <= 0) {
/* sigterm */
err = -1;
break;
}
event = (bcm_event_t *)data;
event_type = ntoh32(event->event.event_type);
reason = ntoh32(event->event.reason);
#ifdef WL_FTM_DEBUG
printf("%s: event_type 0x%x, ntoh32()=0x%x, ltoh32()=0x%x\n",
__FUNCTION__, event->event.event_type, event_type,
ltoh32(event->event.event_type));
#endif /* WL_FTM_DEBUG */
if ((event_type != WLC_E_PROXD)) {
/* may be other BCM events we are not interested in */
#ifdef WL_FTM_DEBUG
printf("WARNING: not a proxd BCM_EVENT:%d\n", event_type);
#endif /* WL_FTM_DEBUG */
continue;
}
/* check 'version' for FTM events */
if (ftm_event_check((bcm_event_t *) data) == 0)
continue; /* continue to rx event */
/* continue to handle non-FTM events */
#ifdef WL_NAN
if (reason == WLC_E_PROXD_NAN_EVENT) {
nanevp = (wl_nan_ranging_event_data_t *)&data[sizeof(bcm_event_t)];
mode = nanevp->mode;
}
else
#endif
if (reason == WLC_E_PROXD_TS_RESULTS) {
tsp = (wl_proxd_event_ts_results_t*)&data[sizeof(bcm_event_t)];
mode = ntoh16(tsp->mode);
} else {
/* move to bcm event payload, which is proxd event structure */
evp = (wl_proxd_event_data_t*)&data[sizeof(bcm_event_t)];
mode = ntoh16(evp->mode);
}
printf("mode:%s; event:",
(mode == WL_PROXD_MODE_INITIATOR)?"initiator":"target");
switch (reason) {
case WLC_E_PROXD_FOUND:
printf("WLC_E_PROXD_FOUND; ");
wl_proxd_tof_host_calc(evp); /* backward compatibility with RSSI method */
break;
case WLC_E_PROXD_GONE:
printf("WLC_E_PROXD_GONE; ");
break;
case WLC_E_PROXD_START:
/* event for targets / accesspoints */
printf("WLC_E_PROXD_START; ");
break;
case WLC_E_PROXD_STOP:
printf("WLC_E_PROXD_STOP; ");
break;
case WLC_E_PROXD_COMPLETED:
printf("WLC_E_PROXD_COMPLETED; ");
/* all new method results should land here */
wl_proxd_tof_host_calc(evp);
if (exit_on1stresult)
goto exit0;
break;
case WLC_E_PROXD_TS_RESULTS:
printf("WLC_E_PROXD_TS_RESULTS; ");
wl_proxd_tof_ts_results(tsp);
if (exit_on1stresult)
goto exit0;
break;
case WLC_E_PROXD_ERROR:
printf("WLC_E_PROXD_ERROR:%d;", evp->err_code);
/* all new method results should land here */
wl_proxd_tof_host_calc(evp);
if (exit_on1stresult)
goto exit0;
break;
case WLC_E_PROXD_COLLECT_START:
printf("WLC_E_PROXD_COLLECT_START; ");
break;
case WLC_E_PROXD_COLLECT_STOP:
printf("WLC_E_PROXD_COLLECT_STOP; ");
break;
case WLC_E_PROXD_COLLECT_COMPLETED:
printf("WLC_E_PROXD_COLLECT_COMPLETED; ");
break;
case WLC_E_PROXD_COLLECT_ERROR:
printf("WLC_E_PROXD_COLLECT_ERROR; ");
break;
#ifdef WL_NAN
case WLC_E_PROXD_NAN_EVENT:
printf("WLC_E_NAN_EVENT; ");
wl_proxd_nan_host_calc(nanevp);
break;
#endif
default:
printf("ERROR: unsupported EVENT reason code:%d; ",
reason);
err = -1;
break;
}
printf("\n");
}
exit0:
/* if we ever reach here */
free(data);
exit1:
close(fd);
/* Read the event mask from driver and mask the event WLC_E_PROXD */
if (!(err = wlu_iovar_get(wl, "event_msgs", &event_inds_mask, WL_EVENTING_MASK_LEN))) {
event_inds_mask[WLC_E_PROXD / 8] &= (~(1 << (WLC_E_PROXD % 8)));
err = wlu_iovar_set(wl, "event_msgs", &event_inds_mask, WL_EVENTING_MASK_LEN);
}
fflush(stdout);
return (err);
}
#endif /* linux */
#if defined(WL_NAN)
static int wl_nan_ranging_config(void *wl, cmd_t *cmd, char **argv)
{
wl_nan_ranging_config_t nanconfig, *pnan_config;
char chspec_str[CHANSPEC_STR_LEN];
int rc;
void *ptr = NULL;
int count;
chanspec_t chanspec;
count = ARGCNT(argv);
/* GET operation */
if (*++argv == NULL) {
if ((rc = wlu_var_getbuf(wl, cmd->name, NULL, 0, &ptr)) < 0)
return rc;
pnan_config = (wl_nan_ranging_config_t *)ptr;
wf_chspec_ntoa(pnan_config->chanspec, chspec_str);
printf("chanspec: %s(0x%04x)\n", chspec_str, pnan_config->chanspec);
printf("timeslot: %d\n", pnan_config->timeslot);
printf("duration: %d\n", pnan_config->duration);
printf("allowed mac: %02x:%02x:%02x:%02x:%02x:%02x\n",
pnan_config->allow_mac.octet[0],
pnan_config->allow_mac.octet[1],
pnan_config->allow_mac.octet[2],
pnan_config->allow_mac.octet[3],
pnan_config->allow_mac.octet[4],
pnan_config->allow_mac.octet[5]);
printf("flags: 0x%04x\n", pnan_config->flags);
return rc;
}
/*
** Set the attributes.
*/
if (count < 4) {
return BCME_USAGE_ERROR;
}
pnan_config = &nanconfig;
if ((chanspec = wf_chspec_aton(*argv)) == 0) {
fprintf(stderr, "%s: could not parse \"%s\" as a channel\n",
cmd->name, *argv);
return BCME_BADARG;
}
pnan_config->chanspec = wl_chspec_to_driver(chanspec);
if (pnan_config->chanspec == INVCHANSPEC) {
fprintf(stderr, "%s: wl_chspec_to_driver() error \"%s\" \n",
cmd->name, *argv);
return BCME_BADARG;
}
pnan_config->timeslot = strtoul(*++argv, NULL, 0);
if (pnan_config->timeslot == 0 || pnan_config->timeslot >= 512) {
fprintf(stderr, "Invalid timeslot \"%s\" \n", *argv);
return BCME_BADARG;
}
pnan_config->duration = strtoul(*++argv, NULL, 0);
if (pnan_config->duration == 0 || pnan_config->duration >= 512) {
fprintf(stderr, "Invalid duration \"%s\" \n", *argv);
return BCME_BADARG;
}
if (*++argv) {
/* MAC address */
if (!wl_ether_atoe(*argv, &pnan_config->allow_mac)) {
fprintf(stderr, "nan ranging config mac addr err\n");
return BCME_BADARG;
}
if (*++argv) {
pnan_config->flags = strtoul(*argv, NULL, 0);
} else
pnan_config->flags = 0;
} else {
memcpy(&pnan_config->allow_mac, &ether_bcast, ETHER_ADDR_LEN);
pnan_config->flags = 0;
}
rc = wlu_var_setbuf(wl, cmd->name, pnan_config, sizeof(wl_nan_ranging_config_t));
return (rc);
}
static int wl_nan_ranging_start(void *wl, cmd_t *cmd, char **argv)
{
const char *str;
wl_nan_ranging_list_t *pnan_list;
int buf_len;
int str_len;
int rc, i;
void *ptr = NULL;
int count;
chanspec_t chanspec;
count = ARGCNT(argv);
/* GET operation */
if (*++argv == NULL) {
if ((rc = wlu_var_getbuf(wl, cmd->name, NULL, 0, &ptr)) < 0)
return rc;
pnan_list = (wl_nan_ranging_list_t *)ptr;
printf("num peers: %d \n", pnan_list->count);
printf("num peers done: %d \n", pnan_list->num_peers_done);
printf("num dws: %d \n", pnan_list->num_dws);
printf("----------------------------------------------------------------------\n");
printf("Address \t\tchanspec\tcount\tretry\tabitmap\tflags\n");
for (i = 0; i < pnan_list->count; i++) {
printf("%02x:%02x:%02x:%02x:%02x:%02x\t0x%04x\t\t%d\t%d\t0x%x\t0x%x\n",
pnan_list->rp[i].ea.octet[0],
pnan_list->rp[i].ea.octet[1],
pnan_list->rp[i].ea.octet[2],
pnan_list->rp[i].ea.octet[3],
pnan_list->rp[i].ea.octet[4],
pnan_list->rp[i].ea.octet[5],
pnan_list->rp[i].chanspec,
pnan_list->rp[i].frmcnt,
pnan_list->rp[i].retrycnt,
pnan_list->rp[i].abitmap,
pnan_list->rp[i].flags);
}
return rc;
}
/*
** Set the attributes.
*/
if ((count % 6) != 2) {
return BCME_USAGE_ERROR;
}
str = cmd->name;
str_len = strlen(str);
strncpy(buf, str, str_len);
buf[ str_len ] = '\0';
pnan_list = (wl_nan_ranging_list_t *) (buf + str_len + 1);
pnan_list->count = count/6;
pnan_list->num_peers_done = 0;
pnan_list->num_dws = strtoul(*argv++, NULL, 0);
for (i = 0; i < pnan_list->count; i++, argv++) {
if ((chanspec = wf_chspec_aton(*argv)) == 0) {
fprintf(stderr, "%s: could not parse \"%s\" as a channel\n",
cmd->name, *argv);
return BCME_BADARG;
}
pnan_list->rp[i].chanspec = wl_chspec_to_driver(chanspec);
if (pnan_list->rp[i].chanspec == INVCHANSPEC) {
fprintf(stderr, "%s: wl_chspec_to_driver() error \"%s\" \n",
cmd->name, *argv);
return BCME_BADARG;
}
if (!wl_ether_atoe(*++argv, &pnan_list->rp[i].ea)) {
fprintf(stderr, "ranging mac addr err\n");
return BCME_BADADDR;
}
pnan_list->rp[i].abitmap = strtoul(*++argv, NULL, 0);
pnan_list->rp[i].frmcnt = strtoul(*++argv, NULL, 0);
if (pnan_list->rp[i].frmcnt >= 255) {
fprintf(stderr, "Invalid frame count \"%s\" \n", *argv);
return BCME_BADARG;
}
pnan_list->rp[i].retrycnt = strtoul(*++argv, NULL, 0);
pnan_list->rp[i].flags = strtoul(*++argv, NULL, 0);
}
fprintf(stderr, "count %d\n", pnan_list->count);
buf_len = str_len + 1 + sizeof(wl_nan_ranging_list_t) +
sizeof(wl_nan_ranging_peer_t) * (pnan_list->count - 1);
rc = wlu_set(wl, WLC_SET_VAR, buf, buf_len);
return (rc);
}
static int wl_nan_ranging_results_host(void *wl, cmd_t *cmd, char **argv)
{
wl_nan_ranging_event_data_t *pnan_event;
int rc, i;
void *ptr = NULL;
UNUSED_PARAMETER(argv);
if ((rc = wlu_var_getbuf(wl, cmd->name, NULL, 0, &ptr)) < 0)
return rc;
pnan_event = (wl_nan_ranging_event_data_t *) ptr;
printf("num results: %d \n", pnan_event->count);
printf("num good results: %d \n", pnan_event->success_count);
printf("------------------------------------------------------------------------------\n");
printf("Address\t\t\tchanspec\tvalidcnt\tts\t\tdist\tstatus\n");
for (i = 0; i < pnan_event->count; i++) {
printf("%02x:%02x:%02x:%02x:%02x:%02x\t",
pnan_event->rr[i].ea.octet[0],
pnan_event->rr[i].ea.octet[1],
pnan_event->rr[i].ea.octet[2],
pnan_event->rr[i].ea.octet[3],
pnan_event->rr[i].ea.octet[4],
pnan_event->rr[i].ea.octet[5]);
printf("%04x\t\t%d\t\t%u\t",
pnan_event->rr[i].chanspec,
pnan_event->rr[i].sounding_count,
pnan_event->rr[i].timestamp);
if (pnan_event->rr[i].distance == 0xffffffff)
printf("-1\t");
else
printf("%d.%04d\t", pnan_event->rr[i].distance >> 4,
(pnan_event->rr[i].distance & 0x0f) * 625);
printf("%s\n", wl_proxd_nan_status_str(pnan_event->rr[i].status));
}
return (rc);
}
#endif /* WL_NAN */
/*
* proxd ftm sub-commands info and handlers
*/
typedef struct ftm_subcmd_info ftm_subcmd_info_t;
typedef int (ftm_cmd_handler_t)(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv);
/* bitmask indicating which command groups; */
typedef enum {
FTM_SUBCMD_FLAG_METHOD = 0x01, /* FTM method command */
FTM_SUBCMD_FLAG_SESSION = 0x02, /* FTM session command */
FTM_SUBCMD_FLAG_ALL = FTM_SUBCMD_FLAG_METHOD | FTM_SUBCMD_FLAG_SESSION
} ftm_subcmd_flag_t;
struct ftm_subcmd_info {
char *name; /* cmd-name string as cmdline input */
wl_proxd_cmd_t cmdid; /* cmd-id */
ftm_cmd_handler_t *handler; /* cmd-handler */
ftm_subcmd_flag_t cmdflag;
char *helpmsg; /* messages for 'wl proxd -h ftm' */
};
#define FTM_IOC_BUFSZ 2048 /* ioc buffsize for our module (> BCM_XTLV_HDR_SIZE) */
/* declare proxd ftm-method command handlers ftm_subcmd_xxxx() */
/* e.g. static ftm_cmd_handler_t ftm_subcmd_get_version; */
#define FTM_SUBCMD_FUNC(suffix) ftm_subcmd_ ##suffix
#define DECL_CMDHANDLER(X) static ftm_cmd_handler_t ftm_subcmd_##X
/* get */
DECL_CMDHANDLER(get_version); /* method-only */
DECL_CMDHANDLER(get_result); /* session-only */
DECL_CMDHANDLER(get_info); /* method + session */
DECL_CMDHANDLER(get_status); /* method + session */
DECL_CMDHANDLER(get_sessions); /* method-only */
DECL_CMDHANDLER(get_counters); /* method + session */
DECL_CMDHANDLER(dump); /* method + session */
DECL_CMDHANDLER(get_ranging_info); /* method-only */
/* set */
DECL_CMDHANDLER(enable); /* method-only */
DECL_CMDHANDLER(disable); /* method-only */
DECL_CMDHANDLER(config); /* method + session */
DECL_CMDHANDLER(start_session); /* session-only */
DECL_CMDHANDLER(burst_request); /* session-only */
DECL_CMDHANDLER(stop_session); /* session-only */
DECL_CMDHANDLER(delete_session); /* session-only */
DECL_CMDHANDLER(clear_counters); /* method + session */
DECL_CMDHANDLER(start_ranging); /* method-only */
DECL_CMDHANDLER(stop_ranging); /* method-only */
DECL_CMDHANDLER(tune); /* method-only both set/get */
static const ftm_subcmd_info_t ftm_cmdlist[] = {
/* (get) wl proxd ftm ver */
{"ver", WL_PROXD_CMD_GET_VERSION, FTM_SUBCMD_FUNC(get_version),
FTM_SUBCMD_FLAG_METHOD, "Get the proxd FTM method API version information" },
/* (get) wl proxd ftm <session-id> result */
{"result", WL_PROXD_CMD_GET_RESULT, FTM_SUBCMD_FUNC(get_result),
FTM_SUBCMD_FLAG_SESSION, "Get a session result" },
/* (get) wl proxd ftm [<session-id>] info */
{"info", WL_PROXD_CMD_GET_INFO, FTM_SUBCMD_FUNC(get_info),
FTM_SUBCMD_FLAG_METHOD | FTM_SUBCMD_FLAG_SESSION,
"Get the detail information for the FTM method or a specific session" },
/* (get) wl proxd ftm [<session-id>] status */
{"status", WL_PROXD_CMD_GET_STATUS, FTM_SUBCMD_FUNC(get_status),
FTM_SUBCMD_FLAG_METHOD | FTM_SUBCMD_FLAG_SESSION,
"Get the status for the FTM method or a specific session" },
/* (get) wl proxd ftm sessions */
{"sessions", WL_PROXD_CMD_GET_SESSIONS, FTM_SUBCMD_FUNC(get_sessions),
FTM_SUBCMD_FLAG_METHOD, "List all sessions" },
/* (get) wl proxd ftm [<session-id>] counters */
{"counters", WL_PROXD_CMD_GET_COUNTERS, FTM_SUBCMD_FUNC(get_counters),
FTM_SUBCMD_FLAG_METHOD | FTM_SUBCMD_FLAG_SESSION,
"Get the counters for the FTM method or a specific session" },
/* (get) wl proxd ftm ranging-info */
{ "ranging-info", WL_PROXD_CMD_GET_RANGING_INFO, FTM_SUBCMD_FUNC(get_ranging_info),
FTM_SUBCMD_FLAG_METHOD,
"Get the ranging information for the FTM method" },
/* (get) wl proxd ftm [<session-id>] dump */
{"dump", WL_PROXD_CMD_DUMP, FTM_SUBCMD_FUNC(dump),
FTM_SUBCMD_FLAG_METHOD | FTM_SUBCMD_FLAG_SESSION,
"Dump all information for the FTM method or a specific session" },
/* (set) wl proxd ftm enable */
{"enable", WL_PROXD_CMD_ENABLE, FTM_SUBCMD_FUNC(enable),
FTM_SUBCMD_FLAG_METHOD, "Enable proximity detection using FTM method" },
/* (set) wl proxd ftm disable */
{"disable", WL_PROXD_CMD_DISABLE, FTM_SUBCMD_FUNC(disable),
FTM_SUBCMD_FLAG_METHOD, "Disable proximity detection using FTM method" },
/* wl proxd ftm [<session-id>] config .... */
{"config", WL_PROXD_CMD_CONFIG, FTM_SUBCMD_FUNC(config),
FTM_SUBCMD_FLAG_METHOD | FTM_SUBCMD_FLAG_SESSION,
"Set the configuration for the FTM method or a specific session" },
/* (set) wl proxd ftm <session-id> start */
{"start", WL_PROXD_CMD_START_SESSION, FTM_SUBCMD_FUNC(start_session),
FTM_SUBCMD_FLAG_SESSION, "Start scheduling the burst(s) for a session" },
/* (set) wl proxd ftm <session-id> burst-request */
{"burst-request", WL_PROXD_CMD_BURST_REQUEST, FTM_SUBCMD_FUNC(burst_request),
FTM_SUBCMD_FLAG_SESSION,
"On initiator, send burst requests and process FTM frames. On target, send FTM frames" },
/* (set) wl proxd ftm <session-id> stop */
{"stop", WL_PROXD_CMD_STOP_SESSION, FTM_SUBCMD_FUNC(stop_session),
FTM_SUBCMD_FLAG_SESSION, "Stop a session" },
/* (set) wl proxd ftm <session-id> delete */
{"delete", WL_PROXD_CMD_DELETE_SESSION, FTM_SUBCMD_FUNC(delete_session),
FTM_SUBCMD_FLAG_SESSION, "Delete a session" },
/* (set) wl proxd ftm [<session-id>] clear_counters */
{"clear-counters", WL_PROXD_CMD_CLEAR_COUNTERS, FTM_SUBCMD_FUNC(clear_counters),
FTM_SUBCMD_FLAG_METHOD | FTM_SUBCMD_FLAG_SESSION,
"Clear the counters for the FTM method or a specific session" },
{"start-ranging", WL_PROXD_CMD_START_RANGING, FTM_SUBCMD_FUNC(start_ranging),
FTM_SUBCMD_FLAG_METHOD, "Start ranging for sessions" },
{ "stop-ranging", WL_PROXD_CMD_STOP_RANGING, FTM_SUBCMD_FUNC(stop_ranging),
FTM_SUBCMD_FLAG_METHOD, "Stop ranging" },
{ "tune", WL_PROXD_CMD_TUNE, FTM_SUBCMD_FUNC(tune),
FTM_SUBCMD_FLAG_METHOD, "proxd_tune" },
};
/*
* get subcmd info for a specific FTM 'cmdname'
* return NULL if specified <cmdname> is not supported.
*/
const ftm_subcmd_info_t *
ftm_get_subcmd_info(char *cmdname)
{
int i;
const ftm_subcmd_info_t *p_subcmd_info;
/* search for the specified cmdname from the pre-defined supported cmd list */
p_subcmd_info = &ftm_cmdlist[0];
for (i = 0; i < (int) ARRAYSIZE(ftm_cmdlist); i++) {
if (stricmp(p_subcmd_info->name, cmdname) == 0)
return p_subcmd_info;
p_subcmd_info++;
}
return NULL; /* cmd not supported */
}
/*
* 'wl proxd ascii-method' handler
* handle 'wl proxd ftm [<session-id>] <cmdname> [<param-name><param-value>]*'
*/
static int
wl_proxd_cmd_method_handler(void *wl, cmd_t *cmd, char **argv)
{
wl_proxd_method_t method;
wl_proxd_session_id_t session_id;
const ftm_subcmd_info_t *p_subcmd_info;
/* ignore the command name 'proxd' */
UNUSED_PARAMETER(cmd);
/* check for "wl proxd -h ftm" or "wl proxd help ftm" --> display the usage */
if (!stricmp(*argv, "-h") || !stricmp(*argv, "help")) {
return ftm_handle_help(++argv); /* return BCME_USAGE_ERROR; */
}
/* parse proxd-method, currently only support 'ftm' */
if (stricmp(*argv, "ftm") != 0) { /* un-supported proxd-method */
printf("error: proxd-method '%s' is not supported\n", *argv);
return BCME_USAGE_ERROR;
}
method = WL_PROXD_METHOD_FTM;
/* skip 'ftm-method' and parse session-id if specified */
session_id = WL_PROXD_SESSION_ID_GLOBAL;
if (*++argv) {
if (isdigit((int)*argv[0])) {
session_id = (wl_proxd_session_id_t) atoi(argv[0]);
argv++; /* skip to 'cmdname' */
}
}
/* parse 'cmd' in "wl proxd ftm [<session-id>] <cmd> [<param-name><param-value>]*" */
if (!*argv) {
printf("error: proxd ftm-method cmdname is not specified\n");
return BCME_USAGE_ERROR;
}
/* search for the specified <cmdname> from the pre-defined supported cmd list */
p_subcmd_info = ftm_get_subcmd_info(*argv);
if (p_subcmd_info == NULL) {
/* cannot find the cmd in the ftm_cmdlist */
printf("error: invalid proxd ftm command '%s'\n", *argv);
return BCME_USAGE_ERROR;
}
/* dispacth cmd to appropriate handler */
if (p_subcmd_info->handler) {
/* For 'method-only' commands, 'session-id' can be omitted */
if (((p_subcmd_info->cmdflag & FTM_SUBCMD_FLAG_METHOD) != 0) &&
((p_subcmd_info->cmdflag & FTM_SUBCMD_FLAG_SESSION) == 0)) {
if (session_id != WL_PROXD_SESSION_ID_GLOBAL) {
printf("proxd ftm %s: error, does not accept non-zero session-id\n",
p_subcmd_info->name);
return BCME_USAGE_ERROR;
}
}
/* For 'session-only' commands, 'session-id' must be provided */
if (((p_subcmd_info->cmdflag & FTM_SUBCMD_FLAG_METHOD) == 0) &&
((p_subcmd_info->cmdflag & FTM_SUBCMD_FLAG_SESSION) != 0)) {
if (session_id == WL_PROXD_SESSION_ID_GLOBAL) {
printf("proxd ftm %s: error, please specify a valid session-id\n",
p_subcmd_info->name);
return BCME_USAGE_ERROR;
}
}
return p_subcmd_info->handler(wl, p_subcmd_info, method, session_id, ++argv);
}
return BCME_OK;
}
/*
* definition for id-string mapping.
* This is used to map an id (can be cmd-id, tlv-id, ....) to a text-string
* for debug-display or cmd-log-display
*/
typedef struct ftm_strmap_entry {
int32 id;
char *text;
} ftm_strmap_entry_t;
/*
* lookup 'id' (as a key) from a table
* if found, return the entry pointer, otherwise return NULL
*/
static const ftm_strmap_entry_t*
ftm_get_strmap_info(int32 id, const ftm_strmap_entry_t *p_table, uint32 num_entries)
{
int i;
const ftm_strmap_entry_t *p_entry;
/* scan thru the table till end */
p_entry = p_table;
for (i = 0; i < (int) num_entries; i++)
{
if (p_entry->id == id)
return p_entry;
p_entry++; /* next entry */
}
return NULL; /* not found */
}
/*
* lookup 'str' (as a key) from a table
* if found, return the entry pointer, otherwise return NULL
*/
static const ftm_strmap_entry_t*
ftm_get_strmap_info_strkey(char *strkey, const ftm_strmap_entry_t *p_table, uint32 num_entries)
{
int i;
const ftm_strmap_entry_t *p_entry;
/* scan thru the table till end */
p_entry = p_table;
for (i = 0; i < (int) num_entries; i++)
{
if (stricmp(p_entry->text, strkey) == 0)
return p_entry;
p_entry++; /* next entry */
}
return NULL; /* not found */
}
/*
* map enum to a text-string for display, this function is called by the following:
* For debug/trace:
* ftm_[cmdid|tlvid]_to_str()
* For TLV-output log for 'get' commands
* ftm_[method|tmu|caps|status|state]_value_to_logstr()
* Input:
* pTable -- point to a 'enum to string' table.
*/
static const char *
ftm_map_id_to_str(int32 id, const ftm_strmap_entry_t *p_table, uint32 num_entries)
{
const ftm_strmap_entry_t*p_entry = ftm_get_strmap_info(id, p_table, num_entries);
if (p_entry)
return (p_entry->text);
return "invalid";
}
/* define entry, e.g. { WL_PROXD_CMD_xxx, "WL_PROXD_CMD_xxx" } */
#define DEF_STRMAP_ENTRY(id) { (id), #id }
#ifdef WL_FTM_DEBUG
/* ftm cmd-id mapping */
static const ftm_strmap_entry_t ftm_cmdid_map[] = {
/* {wl_proxd_cmd_t(WL_PROXD_CMD_xxx), "WL_PROXD_CMD_xxx" }, */
DEF_STRMAP_ENTRY(WL_PROXD_CMD_NONE),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_GET_VERSION),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_ENABLE),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_DISABLE),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_CONFIG),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_START_SESSION),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_BURST_REQUEST),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_STOP_SESSION),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_DELETE_SESSION),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_GET_RESULT),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_GET_INFO),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_GET_STATUS),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_GET_SESSIONS),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_GET_COUNTERS),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_CLEAR_COUNTERS),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_DUMP),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_START_RANGING),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_STOP_RANGING),
DEF_STRMAP_ENTRY(WL_PROXD_CMD_GET_RANGING_INFO),
};
/*
* map a ftm cmd-id to a text-string for display
*/
static const char *
ftm_cmdid_to_str(uint16 cmdid)
{
return ftm_map_id_to_str((int32) cmdid, &ftm_cmdid_map[0], ARRAYSIZE(ftm_cmdid_map));
}
#endif /* WL_FTM_DEBUG */
/* ftm tlv-id mapping */
static const ftm_strmap_entry_t ftm_tlvid_loginfo[] = {
/* { WL_PROXD_TLV_ID_xxx, "text for WL_PROXD_TLV_ID_xxx" }, */
{ WL_PROXD_TLV_ID_NONE, "none" },
{ WL_PROXD_TLV_ID_METHOD, "method" },
{ WL_PROXD_TLV_ID_FLAGS, "flags" },
{ WL_PROXD_TLV_ID_CHANSPEC, "chanspec" },
{ WL_PROXD_TLV_ID_TX_POWER, "tx power" },
{ WL_PROXD_TLV_ID_RATESPEC, "ratespec" },
{ WL_PROXD_TLV_ID_BURST_DURATION, "burst duration" },
{ WL_PROXD_TLV_ID_BURST_PERIOD, "burst period" },
{ WL_PROXD_TLV_ID_BURST_FTM_SEP, "burst ftm sep" },
{ WL_PROXD_TLV_ID_BURST_NUM_FTM, "burst num ftm" },
{ WL_PROXD_TLV_ID_NUM_BURST, "num burst" },
{ WL_PROXD_TLV_ID_FTM_RETRIES, "ftm retries" },
{ WL_PROXD_TLV_ID_BSS_INDEX, "BSS index" },
{ WL_PROXD_TLV_ID_BSSID, "bssid" },
{ WL_PROXD_TLV_ID_INIT_DELAY, "burst init delay" },
{ WL_PROXD_TLV_ID_BURST_TIMEOUT, "burst timeout" },
{ WL_PROXD_TLV_ID_EVENT_MASK, "event mask" },
{ WL_PROXD_TLV_ID_FLAGS_MASK, "flags mask" },
{ WL_PROXD_TLV_ID_PEER_MAC, "peer addr" },
{ WL_PROXD_TLV_ID_FTM_REQ, "ftm req" },
{ WL_PROXD_TLV_ID_LCI_REQ, "lci req" },
{ WL_PROXD_TLV_ID_LCI, "lci" },
{ WL_PROXD_TLV_ID_CIVIC_REQ, "civic req" },
{ WL_PROXD_TLV_ID_CIVIC, "civic" },
{ WL_PROXD_TLV_ID_AVAIL24, "availability" },
{ WL_PROXD_TLV_ID_SESSION_FLAGS, "session flags" },
{ WL_PROXD_TLV_ID_SESSION_FLAGS_MASK, "session flags mask" },
{ WL_PROXD_TLV_ID_RX_MAX_BURST, "rx max bursts" },
{ WL_PROXD_TLV_ID_RANGING_INFO, "ranging info" },
{ WL_PROXD_TLV_ID_RANGING_FLAGS, "ranging flags" },
{ WL_PROXD_TLV_ID_RANGING_FLAGS_MASK, "ranging flags mask" },
{ WL_PROXD_TLV_ID_NAN_MAP_ID, "nan map id" },
{ WL_PROXD_TLV_ID_DEV_ADDR, "dev addr" },
{ WL_PROXD_TLV_ID_AVAIL, "availability" },
{ WL_PROXD_TLV_ID_FTM_REQ_RETRIES, "ftm request retries" },
{ WL_PROXD_TLV_ID_TPK, "FTM TPK" },
/* output - 512 + x */
{ WL_PROXD_TLV_ID_STATUS, "status" },
{ WL_PROXD_TLV_ID_COUNTERS, "counters" },
{ WL_PROXD_TLV_ID_INFO, "info" },
{ WL_PROXD_TLV_ID_RTT_RESULT, "rtt result" },
{ WL_PROXD_TLV_ID_AOA_RESULT, "aoa result" },
{ WL_PROXD_TLV_ID_SESSION_INFO, "session info" },
{ WL_PROXD_TLV_ID_SESSION_STATUS, "session status" },
{ WL_PROXD_TLV_ID_SESSION_ID_LIST, "session ids" },
/* debug tlvs can be added starting 1024 */
{ WL_PROXD_TLV_ID_DEBUG_MASK, "debug mask" },
{ WL_PROXD_TLV_ID_COLLECT, "collect" },
{ WL_PROXD_TLV_ID_STRBUF, "result" }
};
/*
* map a ftm TLV-id to a text-string for display as a 'heading'
*/
static const char *
ftm_tlvid_to_logstr(uint16 tlvid)
{
return ftm_map_id_to_str((int32) tlvid,
&ftm_tlvid_loginfo[0], ARRAYSIZE(ftm_tlvid_loginfo));
}
/*
* The following string mapping tables are used for TLVs display received from 'get' commands
*/
/*
* proximity detection method --> text string mapping
*/
static const ftm_strmap_entry_t ftm_method_value_loginfo[] = {
/* wl_proxd_method_t, text-string */
{ WL_PROXD_METHOD_RSVD1, "RSSI not supported" },
{ WL_PROXD_METHOD_TOF, "11v+BCM proprietary" },
{ WL_PROXD_METHOD_RSVD2, "11v only" },
{ WL_PROXD_METHOD_FTM, "FTM" }, /* IEEE rev mc/2014 */
{ WL_PROXD_METHOD_NONE, "none" }
};
static const char *
ftm_method_value_to_logstr(wl_proxd_method_t method)
{
return ftm_map_id_to_str((int32)method,
&ftm_method_value_loginfo[0], ARRAYSIZE(ftm_method_value_loginfo));
}
/*
* time interval unit --> text string mapping
*/
static const ftm_strmap_entry_t ftm_tmu_value_loginfo[] = {
/* wl_proxd_tmu_t, text-string */
{ WL_PROXD_TMU_TU, "TU" },
{ WL_PROXD_TMU_SEC, "sec" },
{ WL_PROXD_TMU_MILLI_SEC, "ms" },
{ WL_PROXD_TMU_MICRO_SEC, "us" },
{ WL_PROXD_TMU_NANO_SEC, "ns" },
{ WL_PROXD_TMU_PICO_SEC, "ps" }
};
static const char *
ftm_tmu_value_to_logstr(wl_proxd_tmu_t tmu)
{
return ftm_map_id_to_str((int32)tmu,
&ftm_tmu_value_loginfo[0], ARRAYSIZE(ftm_tmu_value_loginfo));
}
/*
* proxd FTM method capabilities --> text string mapping
*/
static const ftm_strmap_entry_t ftm_caps_value_loginfo[] = {
/* wl_proxd_ftm_capts_t, text-string */
{ WL_PROXD_FTM_CAP_FTM1, "FTM" },
{ WL_PROXD_FTM_CAP_NONE, "none" }
};
static const char *
ftm_caps_value_to_logstr(wl_proxd_ftm_caps_t caps)
{
return ftm_map_id_to_str((int32)caps,
&ftm_caps_value_loginfo[0], ARRAYSIZE(ftm_caps_value_loginfo));
}
/*
* status --> text string mapping
*/
static const ftm_strmap_entry_t ftm_status_value_loginfo[] = {
/* wl_proxd_status_t, text-string */
{ WL_PROXD_E_NOT_BCM, "different vendor" },
{ WL_PROXD_E_FRAME_TYPE, "invalid frame type" },
{ WL_PROXD_E_VERNOSUPPORT, "unsupported version" },
{ WL_PROXD_E_SEC_NOKEY, "no key" },
{ WL_PROXD_E_SEC_POLICY, "security policy violation" },
{ WL_PROXD_E_SCAN_INPROCESS, "scan in process" },
{ WL_PROXD_E_BAD_PARTIAL_TSF, "bad partial TSF" },
{ WL_PROXD_E_SCANFAIL, "scan failed" },
{ WL_PROXD_E_NOTSF, "no TSF" },
{ WL_PROXD_E_POLICY, "policy failed" },
{ WL_PROXD_E_INCOMPLETE, "incomplete" },
{ WL_PROXD_E_OVERRIDDEN, "overridden" },
{ WL_PROXD_E_ASAP_FAILED, "ASAP failed" },
{ WL_PROXD_E_NOTSTARTED, "not started" },
{ WL_PROXD_E_INVALIDMEAS, "invalid measurement" },
{ WL_PROXD_E_INCAPABLE, "incapable" },
{ WL_PROXD_E_MISMATCH, "mismatch"},
{ WL_PROXD_E_DUP_SESSION, "dup session" },
{ WL_PROXD_E_REMOTE_FAIL, "remote fail" },
{ WL_PROXD_E_REMOTE_INCAPABLE, "remote incapable" },
{ WL_PROXD_E_SCHED_FAIL, "sched failure" },
{ WL_PROXD_E_PROTO, "protocol error" },
{ WL_PROXD_E_EXPIRED, "expired" },
{ WL_PROXD_E_TIMEOUT, "timeout" },
{ WL_PROXD_E_NOACK, "no ack" },
{ WL_PROXD_E_DEFERRED, "deferred" },
{ WL_PROXD_E_INVALID_SID, "invalid session id" },
{ WL_PROXD_E_REMOTE_CANCEL, "remote cancel" },
{ WL_PROXD_E_CANCELED, "canceled" },
{ WL_PROXD_E_INVALID_SESSION, "invalid session" },
{ WL_PROXD_E_BAD_STATE, "bad state" },
{ WL_PROXD_E_ERROR, "error" },
{ WL_PROXD_E_OK, "OK" }
};
/*
* convert BCME_xxx error codes into related error strings
* note, bcmerrorstr() defined in bcmutils is for BCMDRIVER only,
* this duplicate copy is for WL access and may need to clean up later
*/
static const char *ftm_bcmerrorstrtable[] = BCMERRSTRINGTABLE;
static const char *
ftm_status_value_to_logstr(wl_proxd_status_t status)
{
static char ftm_msgbuf_status_undef[32];
const ftm_strmap_entry_t *p_loginfo;
int bcmerror;
/* check if within BCME_xxx error range */
bcmerror = (int) status;
if (VALID_BCMERROR(bcmerror))
return ftm_bcmerrorstrtable[-bcmerror];
/* otherwise, look for 'proxd ftm status' range */
p_loginfo = ftm_get_strmap_info((int32) status,
&ftm_status_value_loginfo[0], ARRAYSIZE(ftm_status_value_loginfo));
if (p_loginfo)
return p_loginfo->text;
/* report for 'out of range' FTM-status error code */
memset(ftm_msgbuf_status_undef, 0, sizeof(ftm_msgbuf_status_undef));
snprintf(ftm_msgbuf_status_undef, sizeof(ftm_msgbuf_status_undef),
"Undefined status %d", status);
return &ftm_msgbuf_status_undef[0];
}
/*
* session-state --> text string mapping
*/
static const ftm_strmap_entry_t ftm_session_state_value_loginfo[] = {
/* wl_proxd_session_state_t, text string */
{ WL_PROXD_SESSION_STATE_CREATED, "created" },
{ WL_PROXD_SESSION_STATE_CONFIGURED, "configured" },
{ WL_PROXD_SESSION_STATE_STARTED, "started" },
{ WL_PROXD_SESSION_STATE_DELAY, "delay" },
{ WL_PROXD_SESSION_STATE_USER_WAIT, "user-wait" },
{ WL_PROXD_SESSION_STATE_SCHED_WAIT, "sched-wait" },
{ WL_PROXD_SESSION_STATE_BURST, "burst" },
{ WL_PROXD_SESSION_STATE_STOPPING, "stopping" },
{ WL_PROXD_SESSION_STATE_ENDED, "ended" },
{ WL_PROXD_SESSION_STATE_START_WAIT, "start-wait" },
{ WL_PROXD_SESSION_STATE_DESTROYING, "destroying" },
{ WL_PROXD_SESSION_STATE_NONE, "none" }
};
static const char *
ftm_session_state_value_to_logstr(wl_proxd_session_state_t state)
{
return ftm_map_id_to_str((int32)state, &ftm_session_state_value_loginfo[0],
ARRAYSIZE(ftm_session_state_value_loginfo));
}
/*
* ranging-state --> text string mapping
*/
static const ftm_strmap_entry_t ftm_ranging_state_value_loginfo [] = {
/* wl_proxd_ranging_state_t, text string */
{ WL_PROXD_RANGING_STATE_NONE, "none" },
{ WL_PROXD_RANGING_STATE_NOTSTARTED, "nonstarted" },
{ WL_PROXD_RANGING_STATE_INPROGRESS, "inprogress" },
{ WL_PROXD_RANGING_STATE_DONE, "done" },
};
static const char *
ftm_ranging_state_value_to_logstr(wl_proxd_ranging_state_t state)
{
return ftm_map_id_to_str((int32) state, &ftm_ranging_state_value_loginfo[0],
ARRAYSIZE(ftm_ranging_state_value_loginfo));
}
/*
* ranging-flags --> text string mapping
*/
static const ftm_strmap_entry_t ftm_ranging_flags_value_loginfo [] = {
/* wl_proxd_ranging_flags_t, text string */
{ WL_PROXD_RANGING_FLAG_NONE, "none" }, /* no flags */
{ WL_PROXD_RANGING_FLAG_DEL_SESSIONS_ON_STOP, "del sessions on stop" },
{ WL_PROXD_RANGING_FLAG_ALL, "all" },
};
static const char *
ftm_ranging_flags_value_to_logstr(wl_proxd_ranging_flags_t flags)
{
return ftm_map_id_to_str((int32) flags, &ftm_ranging_flags_value_loginfo[0],
ARRAYSIZE(ftm_ranging_flags_value_loginfo));
}
/*
* availability flag --> text string mapping
*/
static const ftm_strmap_entry_t ftm_avail_flags_value_loginfo [] = {
/* wl_proxd_avail_flags_t, text string */
{ WL_PROXD_AVAIL_NONE, "none" },
{ WL_PROXD_AVAIL_NAN_PUBLISHED, "NAN published" },
{ WL_PROXD_AVAIL_SCHEDULED, "scheduled" } /* scheduled by proxd */
};
static const char *
ftm_avail_flags_value_to_logstr(wl_proxd_avail_flags_t flags)
{
return ftm_map_id_to_str((int32) flags, &ftm_avail_flags_value_loginfo[0],
ARRAYSIZE(ftm_avail_flags_value_loginfo));
}
/*
* availability time-ref --> text string mapping
* (use for logging and cmd-line params parsing)
*/
static const ftm_strmap_entry_t ftm_avail_timeref_value_loginfo [] = {
/* wl_proxd_time_ref_t, text string */
{ WL_PROXD_TREF_NONE, "none" },
{ WL_PROXD_TREF_DEV_TSF, "dev-tsf" },
{ WL_PROXD_TREF_NAN_DW, "nan-dw" },
{ WL_PROXD_TREF_TBTT, "tbtt" }
};
static const char *
ftm_avail_timeref_value_to_logstr(wl_proxd_time_ref_t timeref)
{
return ftm_map_id_to_str((int32) timeref, &ftm_avail_timeref_value_loginfo[0],
ARRAYSIZE(ftm_avail_timeref_value_loginfo));
}
/*
* allocate a buffer for get/set 'proxd ftm' iovar
*
* Input:
* tlvs_bufsize: specify the max-size of all TLVs reserved for this buffer
* The following fields will be used for setting the proxd-method iovar header:
* method, session_id, cmdid
*
* if succeeds, this function allocates a buffer, setup proxd-method iovar header
* then returns the pointer to allocated buffer and the bufsize(in bytes)
* to caller. Note, the 'len' and a dummy-TLV will be set in the iovar header,
* caller may adjust the 'len' based on #of valid TLVs later.
* if failed, return 'NULL' to indicate error (e.g. no memory).
*/
static wl_proxd_iov_t *
ftm_alloc_getset_buf(wl_proxd_method_t method, wl_proxd_session_id_t session_id,
wl_proxd_cmd_t cmdid, uint16 tlvs_bufsize, uint16 *p_out_bufsize)
{
uint16 proxd_iovsize;
wl_proxd_tlv_t *p_tlv;
wl_proxd_iov_t *p_proxd_iov = (wl_proxd_iov_t *) NULL;
*p_out_bufsize = 0; /* init */
/* calculate the whole buffer size, including one reserve-tlv entry in the header */
proxd_iovsize = sizeof(wl_proxd_iov_t) + tlvs_bufsize;
p_proxd_iov = calloc(1, proxd_iovsize);
if (p_proxd_iov == NULL) {
printf("error: failed to allocate %d bytes of memory\n", proxd_iovsize);
return NULL;
}
/* setup proxd-FTM-method iovar header */
p_proxd_iov->version = htol16(WL_PROXD_API_VERSION);
p_proxd_iov->len = htol16(proxd_iovsize); /* caller may adjust it based on #of TLVs */
p_proxd_iov->cmd = htol16(cmdid);
p_proxd_iov->method = htol16(method);
p_proxd_iov->sid = htol16(session_id);
/* initialize the reserved/dummy-TLV in iovar header */
p_tlv = p_proxd_iov->tlvs;
p_tlv->id = htol16(WL_PROXD_TLV_ID_NONE);
p_tlv->len = htol16(0);
*p_out_bufsize = proxd_iovsize; /* for caller's reference */
return p_proxd_iov;
}
/*
* unpack and display rtt_result TLV
*/
#define PDFTM_BURST_STATE_NAMES \
{"INVALID", \
"FTM2/M1/RESPONSE", \
"FTM3/M2/LTFTRIGGER", \
"FTM4/M3/DONE", \
}
#define FTM_FRAME_TYPES \
{"SETUP", "TRIGGER", "TIMESTAMP"}
static void
ftm_unpack_and_display_rtt_result(const uint8 *p_data, uint16 tlvid, uint16 len)
{
int i;
char dispbuf[256];
char *p_dest;
wl_proxd_rtt_result_t *p_data_info;
wl_proxd_result_flags_t flags;
wl_proxd_session_state_t session_state;
int32 avg_dist;
wl_proxd_rtt_sample_t *p_sample;
uint16 num_rtt;
char* pstatestr[] = PDFTM_BURST_STATE_NAMES;
char *ftm_frame_types[] = FTM_FRAME_TYPES;
UNUSED_PARAMETER(len);
p_data_info = (wl_proxd_rtt_result_t *) p_data;
/* unpack and format 'flags' for display */
flags = ltoh16_ua(&p_data_info->flags);
memset(dispbuf, 0, sizeof(dispbuf));
p_dest = &dispbuf[0];
if (flags & WL_PROXD_RESULT_FLAG_NLOS) {
strncpy(p_dest, "NLOS", sizeof(dispbuf) - strlen(dispbuf) - 1);
p_dest = &dispbuf[strlen(dispbuf)];
}
if (flags & WL_PROXD_RESULT_FLAG_LOS)
strncpy(p_dest, " LOS", sizeof(dispbuf) - strlen(dispbuf) - 1);
if (flags & WL_PROXD_RESULT_FLAG_FATAL)
strncpy(p_dest, " Fatal error", sizeof(dispbuf) - strlen(dispbuf) - 1);
printf("> %s:\n>\tsessionId=%d, flags=0x%04x('%s'), peer=%s\n",
ftm_tlvid_to_logstr(tlvid),
ltoh16_ua(&p_data_info->sid),
flags,
dispbuf, /* flags */
wl_ether_etoa(&p_data_info->peer));
/* session state and status */
session_state = ltoh16_ua(&p_data_info->state);
printf(">\tsession state=%d(%s)",
session_state, ftm_session_state_value_to_logstr(session_state));
printf(">\tburst_duration: %d%s\n",
ltoh32_ua(&p_data_info->u.burst_duration.intvl),
ftm_tmu_value_to_logstr(ltoh16_ua(&p_data_info->u.burst_duration.tmu)));
/* show avg_dist (1/256m units), burst_num */
avg_dist = ltoh32_ua(&p_data_info->avg_dist);
if ((uint32)avg_dist == 0xffffffff) { /* report 'failure' case */
printf(">\tavg_dist=-1m, burst_num=%d, valid_measure_cnt=%d num_ftm=%d\n",
ltoh16_ua(&p_data_info->burst_num),
p_data_info->num_valid_rtt, p_data_info->num_ftm); /* in a session */
}
else {
printf(">\tavg_dist=%d.%04dm, burst_num=%d, valid_measure_cnt=%d num_ftm=%d\n",
avg_dist >> 8, /* 1/256m units */
((avg_dist & 0xff) * 625) >> 4,
ltoh16_ua(&p_data_info->burst_num),
p_data_info->num_valid_rtt, p_data_info->num_ftm); /* in a session */
}
/* show 'avg_rtt' sample */
p_sample = &p_data_info->avg_rtt;
printf(">\tavg_rtt sample: rssi=%d snr=%d bitflips=%d rtt=%d%s "
"std_deviation =%d.%d ratespec=0x%08x\n",
(wl_proxd_rssi_t) ltoh16_ua(&p_sample->rssi),
(wl_proxd_snr_t) ltoh16_ua(&p_sample->snr),
(wl_proxd_bitflips_t) ltoh16_ua(&p_sample->bitflips),
ltoh32_ua(&p_sample->rtt.intvl),
ftm_tmu_value_to_logstr(ltoh16_ua(&p_sample->rtt.tmu)),
ltoh16_ua(&p_data_info->sd_rtt)/10, ltoh16_ua(&p_data_info->sd_rtt)%10,
ltoh32_ua(&p_sample->ratespec));
printf(">\tnum_measurements: %d ", p_data_info->num_meas);
printf(" Flags:");
if (p_data_info->flags & WL_PROXD_REQUEST_SENT) {
if (p_data_info->flags & WL_PROXD_REQUEST_ACKED) {
if (p_data_info->num_meas)
printf("(%s)", pstatestr[p_data_info->num_meas]);
else
printf("(FTM1/REQSENT/ACKED)");
} else {
printf("(FTM1/REQSENT/NOACK)");
}
} else {
printf("(NO_REQ_SENT)");
}
printf("(LTFSEQ %sSTARTED)\n", (p_data_info->flags & WL_PROXD_LTFSEQ_STARTED)? "":"not ");
/* display detail if available */
num_rtt = ltoh16_ua(&p_data_info->num_rtt);
if (num_rtt > 0)
{
printf(">\tnum rtt: %d samples\n", num_rtt);
p_sample = &p_data_info->rtt[0];
for (i = 0; i < num_rtt; i++)
{
uint16 snr = 0, bitflips = 0;
int16 rssi = 0;
int32 dist = 0;
/* FTM frames 1,4,7,11 have valid snr, rssi and bitflips */
if ((i%TOF_DEFAULT_FTMCNT_SEQ) == 1) {
rssi = (wl_proxd_rssi_t) ltoh16_ua(&p_sample->rssi);
snr = (wl_proxd_snr_t) ltoh16_ua(&p_sample->snr);
bitflips = (wl_proxd_bitflips_t) ltoh16_ua(&p_sample->bitflips);
dist = ltoh32_ua(&p_sample->distance);
} else {
rssi = -1;
snr = 0;
bitflips = 0;
dist = 0;
}
printf(">\t sample[%d]: id=%d rssi=%d snr=%d bitflips=%d "
"dist=%d rtt=%d%s status %s Type %s coreid=%d\n",
i, p_sample->id, rssi, snr, bitflips, dist,
ltoh32_ua(&p_sample->rtt.intvl),
ftm_tmu_value_to_logstr(ltoh16_ua(&p_sample->rtt.tmu)),
ftm_status_value_to_logstr(ltoh32_ua(&p_sample->status)),
ftm_frame_types[i % TOF_DEFAULT_FTMCNT_SEQ], p_sample->coreid);
p_sample++;
}
}
return;
}
/*
* unpack and display session_info TLV (WL_PROXD_TLV_ID_SESSION_INFO)
*/
static void
ftm_unpack_and_display_session_info(const uint8 *p_data, uint16 tlvid, uint16 len)
{
wl_proxd_ftm_session_info_t *p_data_info;
wl_proxd_session_state_t session_state;
wl_proxd_status_t proxd_status;
UNUSED_PARAMETER(len);
p_data_info = (wl_proxd_ftm_session_info_t *) p_data;
printf("> %s: bssidx=%d, bssid=%s\n",
ftm_tlvid_to_logstr(tlvid),
p_data_info->bss_index,
wl_ether_etoa(&p_data_info->bssid));
session_state = ltoh16_ua(&p_data_info->state);
proxd_status = ltoh32_ua(&p_data_info->status);
printf("\tsessionId=%d, state=%d(%s), status=%d(%s), burst_num=%d, "
"meas_start %u.%u\n",
ltoh16_ua(&p_data_info->sid),
session_state,
ftm_session_state_value_to_logstr(session_state),
proxd_status,
ftm_status_value_to_logstr(proxd_status),
ltoh16_ua(&p_data_info->burst_num),
ltoh32_ua(&p_data_info->meas_start_hi), ltoh32_ua(&p_data_info->meas_start_lo));
return;
}
/*
* unpack and display session status TLV (WL_PROXD_TLV_ID_SESSION_STATUS)
*/
static void
ftm_unpack_and_display_session_status(const uint8 *p_data, uint16 tlvid, uint16 len)
{
wl_proxd_ftm_session_status_t *p_data_info;
wl_proxd_session_state_t session_state;
wl_proxd_status_t proxd_status;
UNUSED_PARAMETER(len);
p_data_info = (wl_proxd_ftm_session_status_t *) p_data;
session_state = ltoh16_ua(&p_data_info->state);
proxd_status = ltoh32_ua(&p_data_info->status);
printf("> %s: sessionId=%d, state=%d(%s), status=%d(%s), burst_num=%d\n",
ftm_tlvid_to_logstr(tlvid),
ltoh16_ua(&p_data_info->sid),
session_state,
ftm_session_state_value_to_logstr(session_state),
proxd_status,
ftm_status_value_to_logstr(proxd_status),
ltoh16_ua(&p_data_info->burst_num));
return;
}
/*
* unpack and display session_id lists TLV (WL_PROXD_TLV_ID_COUNTERS)
*/
static void
ftm_unpack_and_display_counters(const uint8 *p_data, uint16 tlvid, uint16 len)
{
wl_proxd_counters_t *p_data_info;
UNUSED_PARAMETER(len);
p_data_info = (wl_proxd_counters_t *) p_data;
printf("> %s:\n\ttx-frame-count=%d, rx-frame_count=%d\n",
ftm_tlvid_to_logstr(tlvid),
ltoh32_ua(&p_data_info->tx), /* tx frame count */
ltoh32_ua(&p_data_info->rx)); /* rx frame count */
printf("\tnoack=%d, txfail=%d num_meas=%d\n",
ltoh32_ua(&p_data_info->noack), /* tx w/o ack */
ltoh32_ua(&p_data_info->txfail), /* tx failures */
ltoh32_ua(&p_data_info->num_meas)); /* tx failures */
printf("\tburst=%d, sessions=%d, max_sessions=%d\n",
ltoh32_ua(&p_data_info->burst), /* # of burst */
ltoh32_ua(&p_data_info->sessions), /* # of sessions */
ltoh32_ua(&p_data_info->max_sessions)); /* max concurrency */
printf("\tsched_fail=%d, timeouts=%d, protocol errors=%d\n",
ltoh32_ua(&p_data_info->sched_fail), /* scheduling failures */
ltoh32_ua(&p_data_info->timeouts), /* timeouts */
ltoh32_ua(&p_data_info->protoerr)); /* protocol err */
printf("\tLCI: tx request=%d, rx request=%d, tx report=%d, rx report=%d\n",
ltoh32_ua(&p_data_info->lci_req_tx), /* tx LCI requests */
ltoh32_ua(&p_data_info->lci_req_rx), /* rx LCI requests */
ltoh32_ua(&p_data_info->lci_rep_tx), /* tx LCI reports */
ltoh32_ua(&p_data_info->lci_rep_rx)); /* rx LCI reports */
printf("\tcivic: tx request=%d, rx request=%d, tx report=%d, "
"rx report=%d\n",
ltoh32_ua(&p_data_info->civic_req_tx), /* tx civic requests */
ltoh32_ua(&p_data_info->civic_req_rx), /* rx civic requests */
ltoh32_ua(&p_data_info->civic_rep_tx), /* tx civic reports */
ltoh32_ua(&p_data_info->civic_rep_rx)); /* rx civic reports */
printf("\tranging: created=%d, done=%d\n",
ltoh32_ua(&p_data_info->rctx), ltoh32_ua(&p_data_info->rctx_done));
printf("\tpublish errors=%d\n", ltoh32_ua(&p_data_info->publish_err));
printf("\tsched on_chan=%d off_chan=%d\n", ltoh32_ua(&p_data_info->on_chan),
ltoh32_ua(&p_data_info->off_chan));
printf("\ttsf %u.%u\n",
ltoh32_ua(&p_data_info->tsf_hi),
ltoh32_ua(&p_data_info->tsf_lo));
return;
}
/*
* unpack and display session_id lists TLV (WL_PROXD_TLV_ID_SESSION_ID_LIST)
*/
static void
ftm_unpack_and_display_session_idlist(const uint8 *p_data, uint16 tlvid, uint16 len)
{
wl_proxd_session_id_list_t *p_data_info;
int i;
uint16 num_ids;
UNUSED_PARAMETER(len);
p_data_info = (wl_proxd_session_id_list_t *) p_data;
num_ids = ltoh16_ua(&p_data_info->num_ids);
printf("> %s: total %d id(s)\n", ftm_tlvid_to_logstr(tlvid), num_ids);
for (i = 0; i < num_ids; i++) {
printf(">\tsession[%d]: %d\n", i, ltoh16_ua(&p_data_info->ids[i]));
}
return;
}
/*
* unpack and display availability TLV
*/
static void
ftm_unpack_and_display_avail(const uint8 *p_data, uint16 tlvid, uint16 len)
{
wl_proxd_avail_t *avail;
wl_proxd_avail24_t *avail24;
wl_proxd_avail_t l_avail;
wl_proxd_avail_flags_t flags;
wl_proxd_time_ref_t time_ref;
uint16 num_slots;
wl_proxd_time_slot_t *avail_slot;
chanspec_t chanspec;
int i;
char dispbuf[256];
UNUSED_PARAMETER(len);
/* unpack and format the avail-header for display */
if (tlvid == WL_PROXD_TLV_ID_AVAIL24) {
avail24 = (wl_proxd_avail24_t *) p_data;
/* convert the old version */
l_avail.flags = avail24->flags;
l_avail.time_ref = avail24->time_ref;
l_avail.num_slots = avail24->num_slots;
l_avail.max_slots = avail24->max_slots;
l_avail.repeat = avail24->repeat;
avail = &l_avail;
avail_slot = &avail24->ts0[0];
}
else { /* WL_PROXD_TLV_ID_AVAIL */
avail = (wl_proxd_avail_t *) p_data;
avail_slot = WL_PROXD_AVAIL_TIMESLOTS(avail);
}
flags = ltoh16_ua(&avail->flags);
time_ref = ltoh16_ua(&avail->time_ref);
num_slots = ltoh16_ua(&avail->num_slots);
printf("> %s:\n>\tflags=0x%04x('%s'), time-ref=0x%04x('%s'), "
"period=%d%s, num_slots=%d, max_slots=%d\n",
ftm_tlvid_to_logstr(tlvid),
flags, ftm_avail_flags_value_to_logstr(flags),
time_ref, ftm_avail_timeref_value_to_logstr(time_ref),
ltoh32_ua(&avail->repeat.intvl),
ftm_tmu_value_to_logstr(ltoh16_ua(&avail->repeat.tmu)),
num_slots, ltoh16_ua(&avail->max_slots));
/* unpack and format the time slots for display */
for (i = 0; i < num_slots; i++) {
printf(">\tslots[%d]: start: %d%s duration: %d%s",
i, ltoh32_ua(&avail_slot->start.intvl),
ftm_tmu_value_to_logstr(ltoh16_ua(&avail_slot->start.tmu)),
ltoh32_ua(&avail_slot->duration.intvl),
ftm_tmu_value_to_logstr(ltoh16_ua(&avail_slot->duration.tmu)));
chanspec = (chanspec_t) ltoh32_ua(&avail_slot->chanspec);
if (wf_chspec_valid(chanspec)) {
memset(dispbuf, 0, sizeof(dispbuf));
wf_chspec_ntoa(chanspec, dispbuf);
printf(" chanspec: 0x%04x(%s)\n", chanspec, dispbuf);
}
else {
printf(" chanspec: 0x%04x(invalid)\n", chanspec);
}
avail_slot++;
}
}
/*
* unpack and display session_info TLV (WL_PROXD_TLV_ID_RANGING_INFO)
*/
static void
ftm_unpack_and_display_ranging_info(const uint8 *p_data, uint16 tlvid, uint16 len)
{
wl_proxd_ranging_info_t *p_data_info;
wl_proxd_status_t proxd_status;
wl_proxd_ranging_state_t state;
wl_proxd_ranging_flags_t flags;
UNUSED_PARAMETER(len);
p_data_info = (wl_proxd_ranging_info_t *) p_data;
printf("> %s:\n", ftm_tlvid_to_logstr(tlvid));
proxd_status = ltoh32_ua(&p_data_info->status);
state = ltoh16_ua(&p_data_info->state);
flags = ltoh16_ua(&p_data_info->flags);
printf("\tstatus=%d(%s), state=%d(%s), flags=0x%04x(%s), num_sids=%d, num_done=%d\n",
proxd_status,
ftm_status_value_to_logstr(proxd_status),
state,
ftm_ranging_state_value_to_logstr(state),
flags,
ftm_ranging_flags_value_to_logstr(flags),
ltoh16_ua(&p_data_info->num_sids),
ltoh16_ua(&p_data_info->num_done));
return;
}
/*
* a callback function, displays (wl_proxd_tlv_t) bcm_xtlv variables rcvd in
* get ioctl's xtlv buffer.
* -- This function processes GET result for all 'proxd ftm' commands, provided
* that XTLV types (AKA the explicit xtlv types) packed into the ioctl buff
* are unique across all 'proxd ftm' ioctl commands
* -- This function is also used to display rx FTM events (content in XTLVs),
* see ftm_event_check().
*/
static int
ftm_unpack_xtlv_cbfn(void *ctx, const uint8 *p_data, uint16 tlvid, uint16 len)
{
int res = BCME_OK;
char dispbuf[256];
wl_proxd_event_type_t event_data;
char event_dispbuf[256];
chanspec_t chanspec;
wl_proxd_intvl_t *p_data_intvl;
wl_proxd_ftm_info_t *p_data_info;
wl_proxd_tpk_t *tpk_info;
#ifdef WL_FTM_DEBUG
/* for 'get' commands :
wl_proxd_iov_t *p_proxd_iov = (wl_proxd_iov_t *) ctx;
for event_check:
ctx is NULL
*/
printf("enter %s(ctx=%p, data=%p, tlvid=%d, len=%d)...\n",
__FUNCTION__, ctx, p_data, tlvid, len);
#else
UNUSED_PARAMETER(ctx);
#endif /* WL_FTM_DEBUG */
memset(dispbuf, 0, sizeof(dispbuf)); /* clear the buffer for display */
switch (tlvid) {
/* data=uint8 as a number, display in decimal */
case WL_PROXD_TLV_ID_BSS_INDEX:
case WL_PROXD_TLV_ID_FTM_RETRIES: /* at FTM level */
case WL_PROXD_TLV_ID_FTM_REQ_RETRIES:
printf("> %s: %d\n", ftm_tlvid_to_logstr(tlvid), *p_data);
break;
/* data=uint16 as a number, display in decimal */
case WL_PROXD_TLV_ID_BURST_NUM_FTM: /* per burst */
case WL_PROXD_TLV_ID_NUM_BURST:
case WL_PROXD_TLV_ID_RX_MAX_BURST:
printf("> %s: %d\n", ftm_tlvid_to_logstr(tlvid), ltoh16_ua(p_data));
break;
/* data=uin32 as a number, display in decimal */
case WL_PROXD_TLV_ID_NONE:
case WL_PROXD_TLV_ID_TX_POWER:
case WL_PROXD_TLV_ID_STATUS: /* not used ? SJL_FIXME */
case WL_PROXD_TLV_ID_NAN_MAP_ID:
printf("> %s: %d\n", ftm_tlvid_to_logstr(tlvid), ltoh32_ua(p_data));
break;
/* data=uint32 as a number, display in hex */
case WL_PROXD_TLV_ID_RATESPEC:
case WL_PROXD_TLV_ID_DEBUG_MASK:
case WL_PROXD_TLV_ID_RANGING_FLAGS:
case WL_PROXD_TLV_ID_RANGING_FLAGS_MASK:
printf("> %s: 0x%x\n", ftm_tlvid_to_logstr(tlvid), ltoh32_ua(p_data));
break;
/* data=uint32 as a number, display in hex */
case WL_PROXD_TLV_ID_FLAGS:
case WL_PROXD_TLV_ID_FLAGS_MASK:
ftm_unpack_and_display_config_flags(p_data, tlvid);
break;
/* data=uint32 as a number, display in hex */
case WL_PROXD_TLV_ID_SESSION_FLAGS:
case WL_PROXD_TLV_ID_SESSION_FLAGS_MASK:
ftm_unpack_and_display_session_flags(p_data, tlvid);
break;
/* data=uint32 as a number, display in hex */
case WL_PROXD_TLV_ID_EVENT_MASK:
{
event_data = ltoh32_ua(p_data);
event_dispbuf[0] = '\0';
#ifdef WL_FTM_DEBUG
/* convert to a readable text-string */
ftm_format_event_mask(event_data, event_dispbuf, sizeof(event_dispbuf));
#endif /* WL_FTM_DEBUG */
printf("> %s: 0x%x %s\n",
ftm_tlvid_to_logstr(tlvid), event_data, event_dispbuf);
}
break;
/* data=uin32 as a number, convert and display a text-string */
case WL_PROXD_TLV_ID_METHOD:
printf("> %s: %s\n", ftm_tlvid_to_logstr(tlvid),
ftm_method_value_to_logstr((wl_proxd_method_t) ltoh32_ua(p_data)));
break;
/* data=uint32 as a chanspec */
case WL_PROXD_TLV_ID_CHANSPEC:
{
chanspec = (chanspec_t) ltoh32_ua(p_data);
if (wf_chspec_valid(chanspec)) {
wf_chspec_ntoa(chanspec, dispbuf);
printf("> %s: %s 0x%04x\n",
ftm_tlvid_to_logstr(tlvid), dispbuf, chanspec);
} else {
printf("> %s: invalid 0x%04x\n",
ftm_tlvid_to_logstr(tlvid), chanspec);
}
}
break;
/* data=intvl */
case WL_PROXD_TLV_ID_BURST_DURATION:
case WL_PROXD_TLV_ID_BURST_PERIOD:
case WL_PROXD_TLV_ID_BURST_FTM_SEP:
case WL_PROXD_TLV_ID_INIT_DELAY:
case WL_PROXD_TLV_ID_BURST_TIMEOUT:
{
p_data_intvl = (wl_proxd_intvl_t *) p_data;
printf("> %s: %d%s\n", ftm_tlvid_to_logstr(tlvid),
ltoh32_ua(&p_data_intvl->intvl),
ftm_tmu_value_to_logstr(ltoh16_ua(&p_data_intvl->tmu)));
}
break;
case WL_PROXD_TLV_ID_BSSID:
case WL_PROXD_TLV_ID_PEER_MAC:
case WL_PROXD_TLV_ID_DEV_ADDR:
printf("> %s: %s\n", ftm_tlvid_to_logstr(tlvid),
wl_ether_etoa((struct ether_addr *)p_data));
break;
case WL_PROXD_TLV_ID_TPK:
{
tpk_info = (wl_proxd_tpk_t *)p_data;
printf("> %s: mac addr%s \n", ftm_tlvid_to_logstr(tlvid),
wl_ether_etoa((struct ether_addr *)&tpk_info->peer));
}
break;
case WL_PROXD_TLV_ID_INFO: /* data=wl_proxd_ftm_info_t */
{
p_data_info = (wl_proxd_ftm_info_t *) p_data;
printf("> %s: capabilities=%s, max sessions=%d, num sessions=%d,"
"rx_max_burst=%d\n",
ftm_tlvid_to_logstr(tlvid),
ftm_caps_value_to_logstr(ltoh16_ua(&p_data_info->caps)),
ltoh16_ua(&p_data_info->max_sessions),
ltoh16_ua(&p_data_info->num_sessions),
ltoh16_ua(&p_data_info->rx_max_burst));
}
break;
case WL_PROXD_TLV_ID_FTM_REQ: /* data=dot11_ftm_req_t, var-len */
printf("> %s: data-len=%d byte(s)\n",
ftm_tlvid_to_logstr(tlvid), len);
if (len > 0)
prhex(NULL, (uint8 *)p_data, len);
break;
case WL_PROXD_TLV_ID_RTT_RESULT: /* data=wl_proxd_rtt_result_t */
ftm_unpack_and_display_rtt_result(p_data, tlvid, len);
break;
case WL_PROXD_TLV_ID_SESSION_INFO: /* data=wl_proxd_ftm_session_info_t */
ftm_unpack_and_display_session_info(p_data, tlvid, len);
break;
case WL_PROXD_TLV_ID_SESSION_STATUS: /* data=wl_proxd_ftm_session_status_t */
ftm_unpack_and_display_session_status(p_data, tlvid, len);
break;
case WL_PROXD_TLV_ID_COUNTERS: /* data=wl_proxd_counters_t */
ftm_unpack_and_display_counters(p_data, tlvid, len);
break;
case WL_PROXD_TLV_ID_SESSION_ID_LIST: /* data=wl_proxd_session_id_list */
ftm_unpack_and_display_session_idlist(p_data, tlvid, len);
break;
case WL_PROXD_TLV_ID_RANGING_INFO: /* data=wl_proxd_ranging_info_t */
ftm_unpack_and_display_ranging_info(p_data, tlvid, len);
break;
case WL_PROXD_TLV_ID_STRBUF:
if (len > 0)
printf("> %s:\n%s\n", ftm_tlvid_to_logstr(tlvid), p_data);
break;
case WL_PROXD_TLV_ID_AVAIL24:
case WL_PROXD_TLV_ID_AVAIL:
ftm_unpack_and_display_avail(p_data, tlvid, len);
break;
case WL_PROXD_TLV_ID_LCI:
case WL_PROXD_TLV_ID_CIVIC:
printf("> %s: data-len=%d byte(s)\n",
ftm_tlvid_to_logstr(tlvid), len);
if (len > 0)
prhex(NULL, (uint8*)p_data, len);
break;
case WL_PROXD_TLV_ID_TUNE:
res = proxd_tune_display((wl_proxd_params_tof_tune_t *)p_data, len);
break;
case WL_PROXD_TLV_ID_AOA_RESULT: /* SJL_FIXME */
case WL_PROXD_TLV_ID_COLLECT: /* SJL_FIXME */
case WL_PROXD_TLV_ID_LCI_REQ: /* SJL_FIXME */
case WL_PROXD_TLV_ID_CIVIC_REQ: /* SJL_FIXME */
/* fall thru (not used/supported now) */
default:
printf("> Unsupported %s: %d\n", ftm_tlvid_to_logstr(tlvid), tlvid);
res = BCME_ERROR;
break;
}
return res;
}
/* pack TLVs for checking if a specific tlv-id is supported or not
* for WL_PROXD_CMD_IS_TLV_SUPPORTED
*/
static int
ftm_pack_tlv_id_support(uint8 *buf, uint16 bufsize, void *ctx, uint16 *all_tlvsize)
{
int err = BCME_OK;
uint16 buf_space_left;
uint16 tlv_id;
wl_proxd_tlv_t *p_tlv = (wl_proxd_tlv_t *) buf;
*all_tlvsize = 0;
if (!ctx)
return BCME_BADARG;
/* TLV buffer starts with a full size, will decrement for each packed TLV */
buf_space_left = bufsize;
tlv_id = htol16(*((uint16 *) ctx));
err = bcm_pack_xtlv_entry((uint8 **) &p_tlv, &buf_space_left,
WL_PROXD_TLV_ID_TLV_ID, sizeof(uint16), (void *) &tlv_id,
BCM_XTLV_OPTION_ALIGN32);
if (err != BCME_OK) {
printf("%s: failed to pack TLVs, err=%d\n",
__FUNCTION__, err);
goto done;
}
/* return the len to include all TLVs(including TLV header) */
*all_tlvsize = (bufsize - buf_space_left);
done:
return err;
}
/*
* check if a tlv-id is supported:
* return BCME_OK if tlv-id is supported
*/
static int
ftm_is_tlv_id_supported(void *wl, uint16 tlv_id)
{
int err;
wl_proxd_iov_t *p_proxd_iov;
uint16 proxd_iovsize;
uint16 all_tlvsize = 0;
wl_proxd_iov_t *p_iovresp = NULL;
/* alloc mem for ioctl header + reserved bufsize for tlvs (initialize to zero) */
p_proxd_iov = ftm_alloc_getset_buf(WL_PROXD_METHOD_FTM,
WL_PROXD_SESSION_ID_GLOBAL, WL_PROXD_CMD_IS_TLV_SUPPORTED,
FTM_IOC_BUFSZ, &proxd_iovsize);
if (p_proxd_iov == NULL) {
err = BCME_NOMEM;
goto done;
}
/* Setup TLVs -- pack a TLV_ID for support checking */
err = ftm_pack_tlv_id_support((uint8 *) &p_proxd_iov->tlvs[0],
proxd_iovsize - WL_PROXD_IOV_HDR_SIZE,
(void *) &tlv_id, &all_tlvsize);
if (err != BCME_OK)
goto done;
/* update the iov header, set len to include all TLVs + header */
proxd_iovsize = all_tlvsize + WL_PROXD_IOV_HDR_SIZE;
p_proxd_iov->len = htol16(proxd_iovsize);
/* submit a 'get' request to see if the tlv-id is supported or not */
err = wlu_var_getbuf(wl, "proxd", p_proxd_iov, proxd_iovsize, (void *) &p_iovresp);
done:
/* clean up */
free(p_proxd_iov);
return err;
}
/*
* send 'proxd' iovar for all ftm get-related commands
*/
static int
ftm_do_get_ioctl(void *wl, wl_proxd_iov_t *p_proxd_iov, uint16 proxd_iovsize,
const ftm_subcmd_info_t *p_subcmd_info)
{
/* for gets we only need to pass ioc header */
wl_proxd_iov_t *p_iovresp = NULL;
int status;
/* send getbuf proxd iovar */
status = wlu_var_getbuf(wl, "proxd", p_proxd_iov, proxd_iovsize, (void *)&p_iovresp);
if (status != BCME_OK) {
#ifdef WL_FTM_DEBUG
printf("%s: failed to send getbuf proxd iovar, status=%d\n",
__FUNCTION__, status);
#endif /* WL_FTM_DEBUG */
return status;
}
if (p_iovresp != NULL) {
int tlvs_len = ltoh16(p_iovresp->len) - WL_PROXD_IOV_HDR_SIZE;
if (tlvs_len < 0)
{
#ifdef WL_FTM_DEBUG
printf("%s: alert, p_iovresp->len(%d) should not be smaller than %d\n",
__FUNCTION__, ltoh16(p_iovresp->len), (int) WL_PROXD_IOV_HDR_SIZE);
#endif /* WL_FTM_DEBUG */
tlvs_len = 0;
}
if (p_subcmd_info->cmdid == WL_PROXD_CMD_GET_VERSION) /* 'wl proxd ftm version' */
printf("> version: 0x%x\n", ltoh16(p_iovresp->version));
#ifdef WL_FTM_DEBUG
printf("%s: p_iovresp->(tlvs=%p,len=%d), tlvs_len=%d, cmdid=%d(%s) ver=0x%x\n",
__FUNCTION__, p_iovresp->tlvs, ltoh16(p_iovresp->len), tlvs_len,
ltoh16(p_iovresp->cmd), ftm_cmdid_to_str(ltoh16(p_iovresp->cmd)),
ltoh16(p_iovresp->version));
#endif /* WL_FTM_DEBUG */
if (tlvs_len > 0)
{
/* unpack TLVs and invokes the cbfn for processing */
status = bcm_unpack_xtlv_buf(p_proxd_iov, (uint8 *)p_iovresp->tlvs,
tlvs_len, BCM_XTLV_OPTION_ALIGN32, ftm_unpack_xtlv_cbfn);
printf("\n");
}
}
return status;
}
/*
* common handler for all get-related proxd method commands (no TLVs params for these commands)
* wl proxd ftm [session-id] <get-subcmd>
* where <get-subcmd> can be "ver", "result", "info", "status",
* "sessions", "counters", "dump"
* Note, this <get-subcmd> does not accept any parameters (i.e. no <param-name><param-value>)
*/
static int
ftm_common_getcmd_handler(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
int status = BCME_OK;
uint16 proxd_iovsize = 0;
#ifdef WL_FTM_DEBUG
printf("enter %s: method=%d, session_id=%d, cmdid=%d(%s)\n",
__FUNCTION__, method, session_id, p_subcmd_info->cmdid,
ftm_cmdid_to_str(p_subcmd_info->cmdid));
#endif /* WL_FTM_DEBUG */
/* alloc mem for ioctl headr + reserved 0 bufsize for tlvs (initialize to zero) */
wl_proxd_iov_t *p_proxd_iov;
p_proxd_iov = ftm_alloc_getset_buf(method, session_id, p_subcmd_info->cmdid,
0, &proxd_iovsize);
if (p_proxd_iov == NULL)
return BCME_NOMEM;
if (*argv == NULL) { /* get */
status = ftm_do_get_ioctl(wl, p_proxd_iov, proxd_iovsize, p_subcmd_info);
} else {
printf("error: proxd ftm %s cmd doesn't accept any parameters\n",
p_subcmd_info->name);
status = BCME_ERROR;
}
/* clean up */
free(p_proxd_iov);
#ifdef WL_FTM_DEBUG
if (status != BCME_OK)
printf("%s failed: status=%d\n", __FUNCTION__, status);
#endif /* WL_FTM_DEBUG */
return status;
}
/*
* get proxd ftm-method version (API version)
* Usage: wl proxd ftm ver
*
* Note, 'session-id' is ignore
*/
static int
ftm_subcmd_get_version(void *wl, const ftm_subcmd_info_t *p_subcmd_info, wl_proxd_method_t method,
wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar and display the 'version' */
return ftm_common_getcmd_handler(wl, p_subcmd_info, method, session_id, argv);
}
/*
* get session result - may be in progress. Both rtt and aoa results returned (as available).
* Also lci and civic location if available.
* Usage: wl proxd ftm <session-id> result
* Note, caller should have verified the session-id before this call.
*/
static int
ftm_subcmd_get_result(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar and display the 'session result' */
return ftm_common_getcmd_handler(wl, p_subcmd_info, method, session_id, argv);
}
/*
* get the global ftm-method info or session-info if session-id is specified.
* Usage:
* wl proxd ftm [<session-id>] info
*/
static int
ftm_subcmd_get_info(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar and display the 'method/session info' */
return ftm_common_getcmd_handler(wl, p_subcmd_info, method, session_id, argv);
}
/*
* get the ftm-method status or session status if session-id is specified.
* Usage: wl proxd ftm [<session-id>] status
*/
static int
ftm_subcmd_get_status(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar and display the 'method/session status' */
return ftm_common_getcmd_handler(wl, p_subcmd_info, method, session_id, argv);
}
/*
* list all sessions for the ftm method
* Usage: wl proxd ftm sessions
*/
static int
ftm_subcmd_get_sessions(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar and display the 'sessions' */
return ftm_common_getcmd_handler(wl, p_subcmd_info, method, session_id, argv);
}
/*
* get the ftm-method counters or sessions counters if session-id is specified.
* Usage:wl proxd ftm [<session-id>] counters
*/
static int
ftm_subcmd_get_counters(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar and display the 'method/session counters' */
return ftm_common_getcmd_handler(wl, p_subcmd_info, method, session_id, argv);
}
/*
* get the global ftm-method ranging-info
* Usage:
* wl proxd ftm ranging-info
*/
static int
ftm_subcmd_get_ranging_info(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar and display the 'ranging info' */
return ftm_common_getcmd_handler(wl, p_subcmd_info, method, session_id, argv);
}
/*
* dump the ftm-method or a session if session-id is specified.
* Usage: wl proxd ftm [<session-id>] dump
*/
static int
ftm_subcmd_dump(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar and display the 'dump result' */
return ftm_common_getcmd_handler(wl, p_subcmd_info, method, session_id, argv);
}
/* ***************************** set commands ********************* */
/*
* common handler for set-related proxd method commands which require no TLV as input
* wl proxd ftm [session-id] <set-subcmd>
* e.g.
* wl proxd ftm enable -- to enable ftm
* wl proxd ftm disable -- to disable ftm
* wl proxd ftm <session-id> start -- to start a specified session
* wl proxd ftm <session-id> stop -- to cancel a specified session;
* state is maintained till session is delete.
* wl proxd ftm <session-id> delete -- to delete a specified session
* wl proxd ftm [<session-id>] clear-counters -- to clear counters
* wl proxd ftm <session-id> burst-request -- on initiator: to send burst request;
* on target: send FTM frame
* wl proxd ftm <session-id> collect
* wl proxd ftm tune (TBD)
*/
static int
ftm_subcmd_setiov_no_tlv(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
uint16 proxd_iovsize;
wl_proxd_iov_t *p_proxd_iov;
int res;
UNUSED_PARAMETER(wl);
#ifdef WL_FTM_DEBUG
printf("enter %s: method=%d, session_id=%d, cmdid=%d(%s)\n",
__FUNCTION__, method, session_id,
p_subcmd_info->cmdid, ftm_cmdid_to_str(p_subcmd_info->cmdid));
#endif /* WL_FTM_DEBUG */
/* do not accept any parameters */
if (*argv != NULL)
{
printf("error: proxd ftm %s cmd doesn't accept any parameters\n",
p_subcmd_info->name);
return BCME_USAGE_ERROR;
}
/* allocate and initialize a temp buffer for 'set proxd' iovar */
proxd_iovsize = 0;
p_proxd_iov = ftm_alloc_getset_buf(method, session_id, p_subcmd_info->cmdid,
0, &proxd_iovsize); /* no TLV */
if (p_proxd_iov == NULL)
return BCME_NOMEM;
/* no TLV to pack, simply issue a set-proxd iovar */
res = wlu_var_setbuf(wl, "proxd", (void *) p_proxd_iov, proxd_iovsize);
if (res != BCME_OK) {
printf("error: IOVAR failed, status=%d\n", res);
}
/* clean up */
free(p_proxd_iov);
return res;
}
/*
* enable FTM method
* Usage: wl proxd ftm enable
*/
static int
ftm_subcmd_enable(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar call */
return ftm_subcmd_setiov_no_tlv(wl, p_subcmd_info, method, session_id, argv);
}
/*
* disable FTM method
* Usage: wl proxd ftm disable
*/
static int
ftm_subcmd_disable(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar call */
return ftm_subcmd_setiov_no_tlv(wl, p_subcmd_info, method, session_id, argv);
}
/*
* start scheduling the burst(s) for the session. Initiates FTM request or await requests on target.
* Usage: wl proxd ftm <session-id> start
*
* Note, caller should have verified the session-id before this call.
*/
static int
ftm_subcmd_start_session(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar call */
return ftm_subcmd_setiov_no_tlv(wl, p_subcmd_info, method, session_id, argv);
}
/*
* cancel the session. State maintained until session is deleted.
* Usage: wl proxd ftm <session-id> stop
*
* Note, caller should have verify the session-id before this call.
*/
static int ftm_subcmd_stop_session(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar call */
return ftm_subcmd_setiov_no_tlv(wl, p_subcmd_info, method, session_id, argv);
}
/*
* burst request: on initiator send burst request and process FTM frames.
* On target, send FTM frames
* Usage: wl proxd ftm <session-id> burst-request
*
* Note, caller should have verified the session-id before this call.
*/
static int
ftm_subcmd_burst_request(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar call */
return ftm_subcmd_setiov_no_tlv(wl, p_subcmd_info, method, session_id, argv);
}
/*
* delete the session.
* Usage: wl proxd ftm <session-id> delete
*
* Note, caller should have verify the session-id before this call.
*/
static int
ftm_subcmd_delete_session(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar call */
return ftm_subcmd_setiov_no_tlv(wl, p_subcmd_info, method, session_id, argv);
}
/*
* clear counters
* Usage: wl proxd ftm [<session-id>] clear_counters
*
* Note, caller should have verify the session-id before this call.
*/
static int
ftm_subcmd_clear_counters(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* issue an iovar call */
return ftm_subcmd_setiov_no_tlv(wl, p_subcmd_info, method, session_id, argv);
}
/*
* define param-info for global/session 'non-options' configuration for
* 'wl proxd ftm [<session-id>] config [<param-name> <param-value>]*'
*/
typedef struct ftm_config_param_info {
char *name; /* <param-name> string to identify a configurable item */
uint16 tlvid; /* mapping TLV id for the item */
char *name_helpmsg; /* help message for the <param-name> config-item */
ftm_subcmd_flag_t cmdflag; /* supported group(s) */
} ftm_config_param_info_t;
static const ftm_config_param_info_t ftm_config_param_info[] = {
/* "name", tlv_id param-name helpmsg */
{ "bssidx", WL_PROXD_TLV_ID_BSS_INDEX, "BSS index to use for the session",
FTM_SUBCMD_FLAG_ALL },
{ "chanspec", WL_PROXD_TLV_ID_CHANSPEC, "channel spec to use",
FTM_SUBCMD_FLAG_ALL },
{ "tx-power", WL_PROXD_TLV_ID_TX_POWER, "tx power to use in dbm",
FTM_SUBCMD_FLAG_ALL },
{ "ratespec", WL_PROXD_TLV_ID_RATESPEC, "rate to use",
FTM_SUBCMD_FLAG_ALL },
{ "num-ftm", WL_PROXD_TLV_ID_BURST_NUM_FTM, "number of FTM frames in a burst",
FTM_SUBCMD_FLAG_ALL },
{ "num-burst", WL_PROXD_TLV_ID_NUM_BURST, "number of bursts in the session",
FTM_SUBCMD_FLAG_ALL },
{ "retries", WL_PROXD_TLV_ID_FTM_RETRIES, "number of retries; not 802.11 mac level retries",
FTM_SUBCMD_FLAG_ALL },
{ "event-mask", WL_PROXD_TLV_ID_EVENT_MASK, "bitmask of subscribed events",
FTM_SUBCMD_FLAG_ALL },
{ "debug-mask", WL_PROXD_TLV_ID_DEBUG_MASK, "bitmask for logging FTM messages",
FTM_SUBCMD_FLAG_ALL },
{ "burst-duration", WL_PROXD_TLV_ID_BURST_DURATION, "duration for a single burst",
FTM_SUBCMD_FLAG_ALL },
{ "burst-period", WL_PROXD_TLV_ID_BURST_PERIOD, "time between bursts",
FTM_SUBCMD_FLAG_ALL },
{ "ftm-sep", WL_PROXD_TLV_ID_BURST_FTM_SEP, "time between FTM frames in a burst",
FTM_SUBCMD_FLAG_ALL },
{ "burst-timeout", WL_PROXD_TLV_ID_BURST_TIMEOUT, "timeout",
FTM_SUBCMD_FLAG_ALL },
{ "init-delay", WL_PROXD_TLV_ID_INIT_DELAY, "delay after start",
FTM_SUBCMD_FLAG_ALL },
{ "bssid", WL_PROXD_TLV_ID_BSSID, "BSSID used for the session",
FTM_SUBCMD_FLAG_ALL },
{ "peer", WL_PROXD_TLV_ID_PEER_MAC, "peer mac address",
FTM_SUBCMD_FLAG_ALL },
{ "rx-max-burst", WL_PROXD_TLV_ID_RX_MAX_BURST, "limit bursts for rx(method only)",
FTM_SUBCMD_FLAG_METHOD },
/* special 'config options', no matching TLV */
{ "options", WL_PROXD_TLV_ID_NONE,
"type 'wl proxd -h ftm config options' for more information",
FTM_SUBCMD_FLAG_ALL },
{ "session-options", WL_PROXD_TLV_ID_NONE,
"type 'wl proxd -h ftm config options' for more information",
FTM_SUBCMD_FLAG_ALL },
{ "avail", WL_PROXD_TLV_ID_NONE,
"type 'wl proxd -h ftm config avail' for more information",
FTM_SUBCMD_FLAG_ALL },
{ "nan-map-id", WL_PROXD_TLV_ID_NAN_MAP_ID, "NAN map id(method only)",
FTM_SUBCMD_FLAG_METHOD },
{ "dev-addr", WL_PROXD_TLV_ID_DEV_ADDR, "deivce address(method only)",
FTM_SUBCMD_FLAG_METHOD },
{ "req-retries", WL_PROXD_TLV_ID_FTM_REQ_RETRIES, "number of FTM request retries",
FTM_SUBCMD_FLAG_ALL },
{ "tpk", WL_PROXD_TLV_ID_TPK, "tpk to be configured", FTM_SUBCMD_FLAG_ALL }
};
/* map a specified text-string to a proxd time unit
*
* return true if succeeds, otherwise return false.
*/
static bool
ftm_get_tmu_from_str(char *str, wl_proxd_tmu_t *p_tmu)
{
if (stricmp(str, "tu") == 0)
*p_tmu = WL_PROXD_TMU_TU;
else if (stricmp(str, "s") == 0)
*p_tmu = WL_PROXD_TMU_SEC;
else if (stricmp(str, "ms") == 0)
*p_tmu = WL_PROXD_TMU_MILLI_SEC;
else if (stricmp(str, "us") == 0)
*p_tmu = WL_PROXD_TMU_MICRO_SEC;
else if (stricmp(str, "ns") == 0)
*p_tmu = WL_PROXD_TMU_NANO_SEC;
else if (stricmp(str, "ps") == 0)
*p_tmu = WL_PROXD_TMU_PICO_SEC;
else
return FALSE;
return TRUE;
}
/*
* get the config_param_info from the table based on 'param-name' for 'wl proxd ftm config' command
*
* return NULL if 'param-name' is not supported
*/
static const ftm_config_param_info_t *
ftm_get_config_param_info(char *p_param_name, wl_proxd_session_id_t session_id)
{
int i;
ftm_subcmd_flag_t search_cmdflag;
const ftm_config_param_info_t *p_config_param_info;
/* determine if this is for 'session' or 'method' config */
search_cmdflag = (session_id == WL_PROXD_SESSION_ID_GLOBAL) ? FTM_SUBCMD_FLAG_METHOD
: FTM_SUBCMD_FLAG_SESSION;
p_config_param_info = &ftm_config_param_info[0];
for (i = 0; i < (int) ARRAYSIZE(ftm_config_param_info); i++) {
if (stricmp(p_param_name, p_config_param_info->name) == 0) {
/* check if this config-param is supported for method/session */
if ((p_config_param_info->cmdflag & search_cmdflag) == 0) {
/* not supported for this method/session command */
return (ftm_config_param_info_t *) NULL;
}
return p_config_param_info;
}
p_config_param_info++; /* next */
}
return (ftm_config_param_info_t *) NULL; /* 'invalid param name' */
}
/*
* define param-value info for global/session 'options' configuration for
* 'wl proxd ftm [<session-id>] config options {[+|-]<param-value>}*'
*/
typedef struct ftm_config_options_info {
char *param_value_str; /* <param-value> str to identify an options-flag */
uint32 flags; /* wl_proxd_flags_t/wl_proxd_session_flags_t */
char *helpmsg; /* help message for the param-value */
} ftm_config_options_info_t;
/* global/method config options/flags */
static const ftm_config_options_info_t ftm_method_options_info[] = {
/* param-value-string wl_proxd_flags_t helpmsg */
{ "rx-enable", WL_PROXD_FLAG_RX_ENABLED,
"If enabled, process requests; If disabled, requests will be ignored"},
{ "rx-range-req", WL_PROXD_FLAG_RX_RANGE_REQ,
"If enabled, process 11mc range requests; If disabled, requests will be ignored" },
{ "tx-lci", WL_PROXD_FLAG_TX_LCI, "transmit LCI, if available" },
{ "tx-civic", WL_PROXD_FLAG_TX_CIVIC, "tx civic location, if available" },
{ "rx-auto-burst", WL_PROXD_FLAG_RX_AUTO_BURST,
"If enabled, respond to requests without host action.\n"
"\t\t "
"If disabled, the request is forwarded to host via an event.\n"
"\t\t "
"If the event is masked, the request is dropped" },
{ "tx-auto-burst", WL_PROXD_FLAG_TX_AUTO_BURST,
"If enabled, continue an initiated session with a new burst without host action\n"
"\t\t "
"until the number of bursts for the session is completed" },
{ "avail-publish", WL_PROXD_FLAG_AVAIL_PUBLISH, "publish local availability" },
{ "avail-schedule", WL_PROXD_FLAG_AVAIL_SCHEDULE, "schedule local availability" },
{ "asap-capable", WL_PROXD_FLAG_ASAP_CAPABLE, "capable of ASAP scheduling"},
{ "mburst-followup", WL_PROXD_FLAG_MBURST_FOLLOWUP,
"enable multi-burst followup algorithm " },
{ "secure", WL_PROXD_FLAG_SECURE,
"Enable security for ftm - per BSS" },
{ "all", WL_PROXD_FLAG_ALL, "all of the above" }
};
/* config session options/flags */
static const ftm_config_options_info_t ftm_session_options_info[] = {
/* param-value-string wl_proxd_session_flags_t helpmsg */
{ "initiator", WL_PROXD_SESSION_FLAG_INITIATOR, "local device is an initiator" },
{ "target", WL_PROXD_SESSION_FLAG_TARGET, "local device is a target" },
{ "one-way", WL_PROXD_SESSION_FLAG_ONE_WAY, "(initiated) 1-way rtt " },
{ "auto-burst", WL_PROXD_SESSION_FLAG_AUTO_BURST, "created with rx_auto_burst" },
{ "immediate", WL_PROXD_SESSION_FLAG_MBURST_NODELAY, "immediate next burst" },
{ "rtt-detail", WL_PROXD_SESSION_FLAG_RTT_DETAIL, "provide rtt detail in results" },
#ifdef SJL_FIXME
{ "aoa", WL_PROXD_SESSION_FLAG_AOA, "AOA along with RTT" },
#endif /* SJL_FIXME */
{ "rx-auto-burst", WL_PROXD_SESSION_FLAG_RX_AUTO_BURST,
"Same as proxd flags above, applies to the session" },
{ "tx-auto-burst", WL_PROXD_SESSION_FLAG_TX_AUTO_BURST,
"Same as proxd flags above, applies to the session" },
{ "nan-bss", WL_PROXD_SESSION_FLAG_NAN_BSS, "Use NAN BSS, if applicable" },
{ "ts1", WL_PROXD_SESSION_FLAG_TS1, "FTM1 - ASAP-capable" }, /* readonly */
#ifdef SJL_FIXME
{ "rpt-failure", WL_PROXD_SESSION_FLAG_REPORT_FAILURE,
"(target) report not rx distance to host" },
#endif /* SJL_FIXME */
{ "initiator-rpt", WL_PROXD_SESSION_FLAG_INITIATOR_RPT,
"tx initiator-report to target" },
{ "neutral", WL_PROXD_SESSION_FLAG_NETRUAL, "neutral mode" },
{ "seq-en", WL_PROXD_SESSION_FLAG_SEQ_EN, "sequence sampling capture" },
{"no-param-override", WL_PROXD_SESSION_FLAG_NO_PARAM_OVRD,
"disallow override from target"},
{"asap", WL_PROXD_SESSION_FLAG_ASAP, "use ASAP scheduling"},
{ "tx-lci-req", WL_PROXD_SESSION_FLAG_REQ_LCI, "transmit LCI request" },
{ "tx-civic-req", WL_PROXD_SESSION_FLAG_REQ_CIV, "tx civic location request" },
{ "pre-scan", WL_PROXD_SESSION_FLAG_PRE_SCAN, "enable asap pre-scan on initiator" },
{ "auto-vhtack", WL_PROXD_SESSION_FLAG_AUTO_VHTACK, "use vhtack based on brcm ie" },
{ "vhtack", WL_PROXD_SESSION_FLAG_VHTACK, "vht ack is in use - output only" },
{ "burst-duration-nopref", WL_PROXD_SESSION_FLAG_BDUR_NOPREF,
"duration for a single burst - no preference" },
{ "num-ftm-nopref", WL_PROXD_SESSION_FLAG_NUM_FTM_NOPREF,
"number of FTM frames in a burst - no preference" },
{ "ftm-sep-nopref", WL_PROXD_SESSION_FLAG_FTM_SEP_NOPREF,
"time between FTM frames in a burst - no preference " },
{ "num-burst-nopref", WL_PROXD_SESSION_FLAG_NUM_BURST_NOPREF,
"number of bursts in a session - no preference " },
{ "burst-period-nopref", WL_PROXD_SESSION_FLAG_BURST_PERIOD_NOPREF,
"time between bursts - no preference " },
{ "all", WL_PROXD_SESSION_FLAG_ALL, "all of the above" }
};
static void
ftm_cmn_display_config_options_value(uint32 flags,
const ftm_config_options_info_t *p_table, uint32 num_entries)
{
const ftm_config_options_info_t *p_entry;
uint32 i;
if (flags) {
printf(" (");
/* walk thru the table to find a match indicating
the specified param_value_str is valid
*/
p_entry = p_table;
for (i = 0; i < num_entries; i++) {
if ((p_entry->flags & flags) == p_entry->flags) {
printf(" %s", p_entry->param_value_str);
}
p_entry++; /* next */
}
printf(" )");
}
printf("\n");
}
static void
ftm_unpack_and_display_session_flags(const uint8 *p_data, uint16 tlvid)
{
wl_proxd_session_flags_t flags = ltoh32_ua(p_data);
printf("> %s: 0x%x", ftm_tlvid_to_logstr(tlvid), flags);
/* display the value in a readable format */
ftm_cmn_display_config_options_value((uint32) flags,
&ftm_session_options_info[0], ARRAYSIZE(ftm_session_options_info));
}
static void
ftm_unpack_and_display_config_flags(const uint8 *p_data, uint16 tlvid)
{
wl_proxd_flags_t flags = ltoh32_ua(p_data);
printf("> %s: 0x%x", ftm_tlvid_to_logstr(tlvid), flags);
/* display the value in a readable format */
return ftm_cmn_display_config_options_value((uint32) flags,
&ftm_method_options_info[0], ARRAYSIZE(ftm_method_options_info));
}
/* get the method/session config-options info from the table based on 'options param_value_str'
* Input:
* param_value_str -- a 'config options' param-value string to identify a config-options flag
* useMethod -- set to true to look up 'config options' table for FTM method
* set to false to look up 'config options' table for a session
* if succeeds, return a pointer to the config_options_info, otherwise return NULL
*/
static const ftm_config_options_info_t *
ftm_get_config_options_info(char *param_value_str, bool useMethod)
{
int i;
const ftm_config_options_info_t *p_entry;
int num_entries;
if (useMethod) { /* choose an options table for method command */
p_entry = &ftm_method_options_info[0];
num_entries = ARRAYSIZE(ftm_method_options_info);
}
else { /* choose an options table for sessions command */
p_entry = &ftm_session_options_info[0];
num_entries = ARRAYSIZE(ftm_session_options_info);
}
/* walk thru the table to find a match indicating the specified param_value_str is valid */
for (i = 0; i < num_entries; i++) {
if (stricmp(param_value_str, p_entry->param_value_str) == 0)
return p_entry;
p_entry++; /* next */
}
return (ftm_config_options_info_t *) NULL; /* 'invalid param value' */
}
/*
* handle 'wl proxd ftm [<session-id>] config options [+|-]param-value'
* parse cmd-line, setup method/sessions options/flags TLVs in caller
* provided buffer and adjusted-buffer-space if applies.
* Note, input '<session-id>' is used to determine if config-options is
* for 'global/method' or 'sessions'.
*
* This function is invoked from ftm_subcmd_config().
*/
static int
ftm_handle_config_options(wl_proxd_session_id_t session_id, char **argv,
wl_proxd_tlv_t **p_tlv, uint16 *p_buf_space_left, bool useMethod)
{
bool bEnable;
int status;
char *p_param_value;
uint32 flags = WL_PROXD_FLAG_NONE;
uint32 flags_mask = WL_PROXD_FLAG_NONE;
uint32 new_mask; /* cmdline input */
const ftm_config_options_info_t *p_options_info;
UNUSED_PARAMETER(session_id);
/* check if user provides param-values for 'config options' command */
if (*argv == NULL)
return BCME_USAGE_ERROR;
/* <param-value> followed 'wl proxd ftm [session-id] config options' */
while (*argv != NULL) {
bEnable = TRUE; /* default: set the flag if '+/-' is omitted */
if ((*argv)[0] == '-' || (*argv)[0] == '+') {
bEnable = ((*argv)[0] == '-') ? FALSE : TRUE;
p_param_value = *argv + 1; /* skip the prefix */
if (*p_param_value == '\0')
return BCME_USAGE_ERROR;
}
else
p_param_value = *argv;
/* check if 'param-value' (specified in ascii-string) is valid */
p_options_info = ftm_get_config_options_info(p_param_value, useMethod);
if (p_options_info != (ftm_config_options_info_t *) NULL) {
new_mask = p_options_info->flags;
}
else {
/* check if specifed as an intergral number string */
new_mask = strtoul(p_param_value, NULL, 0);
if (new_mask == 0) { /* conversion error, abort */
printf("error: invalid param-value(%s)\n", p_param_value);
return BCME_USAGE_ERROR; /* param-value is invalid */
}
}
/* update flags mask */
flags_mask = flags_mask | new_mask;
if (bEnable)
flags |= new_mask; /* set the bit on */
else
flags &= ~new_mask; /* set the bit off */
argv++; /* continue on next <param-value> */
}
#ifdef WL_FTM_DEBUG
printf("%s: about to set TLVs for %s-options flags_mask=0x%x flags=0x%x\n",
__FUNCTION__, useMethod ? "method" : "sessions", flags_mask, flags);
#endif /* WL_FTM_DEBUG */
flags = htol32(flags);
flags_mask = htol32(flags_mask);
/* setup flags_mask TLV */
status = bcm_pack_xtlv_entry((uint8 **)p_tlv, p_buf_space_left,
useMethod ? WL_PROXD_TLV_ID_FLAGS_MASK : WL_PROXD_TLV_ID_SESSION_FLAGS_MASK,
sizeof(uint32), (uint8 *)&flags_mask, BCM_XTLV_OPTION_ALIGN32);
if (status != BCME_OK) {
#ifdef WL_FTM_DEBUG
printf("%s: bcm_pack_xltv_entry() for flags_mask failed, status=%d\n",
__FUNCTION__, status);
#endif /* WL_FTM_DEBUG */
return status; /* abort */
}
/* setup flags TLV */
status = bcm_pack_xtlv_entry((uint8 **)p_tlv, p_buf_space_left,
useMethod ? WL_PROXD_TLV_ID_FLAGS : WL_PROXD_TLV_ID_SESSION_FLAGS,
sizeof(uint32), (uint8 *)&flags, BCM_XTLV_OPTION_ALIGN32);
if (status != BCME_OK) {
#ifdef WL_FTM_DEBUG
printf("%s: bcm_pack_xltv_entry() for flags failed, status=%d\n",
__FUNCTION__, status);
#endif /* WL_FTM_DEBUG */
return status; /* abort */
}
return BCME_OK;
}
/*
num_burst must be power of 2 (max exponent is 14)
*/
static int
ftm_validate_num_burst(uint16 num_burst, const ftm_config_param_info_t *p_config_param_info)
{
#define WL_FTM_MAX_NUM_BURST_EXP 14
uint16 exponent;
uint64 x_num_burst;
int i;
/* get the exponent value */
exponent = 0;
x_num_burst = (uint64) num_burst;
for (i = 0; i < (int) (sizeof(num_burst) * NBBY); ++i, x_num_burst >>= 1) {
if (x_num_burst & 0x1)
exponent = i;
}
if (exponent > WL_FTM_MAX_NUM_BURST_EXP) {
printf("error:' %s' value is out of range (should not exceed 0x%x)\n",
p_config_param_info->name, 1 << WL_FTM_MAX_NUM_BURST_EXP);
return BCME_RANGE;
}
if (num_burst != (1 << exponent)) {
printf("error: '%s' value must be power of 2\n",
p_config_param_info->name);
return BCME_RANGE; /* not power of 2 */
}
return BCME_OK;
}
/*
parse 'param-value' for 'ftm config' command
*/
static int
ftm_config_parse_ul(char **argv, const ftm_config_param_info_t *p_config_param_info,
unsigned long int min_value, unsigned long int max_value,
unsigned long int *out_data)
{
int status = BCME_OK;
unsigned long int tmp_data_ul;
tmp_data_ul = strtoul(*argv, NULL, 0);
if (tmp_data_ul < min_value || tmp_data_ul > max_value) {
printf("error: '%s' value is out of range\n",
p_config_param_info->name);
return BCME_RANGE;
}
/* validate the arguments */
if (p_config_param_info->tlvid == WL_PROXD_TLV_ID_NUM_BURST ||
p_config_param_info->tlvid == WL_PROXD_TLV_ID_RX_MAX_BURST) {
status = ftm_validate_num_burst((uint16) tmp_data_ul, p_config_param_info);
if (status != BCME_OK)
return status;
}
/* param-value parsing: success */
*out_data = tmp_data_ul;
return BCME_OK;
}
/*
* parse and pack 'chanspec' from a command-line argument
* Input:
* arg_channel: a channel-string
* out_channel: buffer to store the result
*/
static int
ftm_config_parse_channel(char *arg_channel, uint32 *out_channel)
{
int status = BCME_OK;
uint32 src_data_channel = 0; /* default: invalid */
/* note, chanespec_t is currently defined as 16-bit, however */
/* wl-interface use 'uint32' to allow future change for 32-bit */
if (arg_channel != (char *) NULL)
src_data_channel = (uint32) wf_chspec_aton(arg_channel);
if (src_data_channel == 0) {
printf("error: invalid chanspec\n");
status = BCME_BADARG;
}
*out_channel = htol32(src_data_channel);
return status;
}
/*
* parse and pack 'intvl' param-value from a command-line argument
* Input:
* arg_intvl: a time-intvl string
* out_intvl: buffer to store the result
*/
static int
ftm_config_parse_intvl(char *arg_intvl, wl_proxd_intvl_t *out_intvl)
{
wl_proxd_intvl_t src_data_intvl;
char *p_end;
/* initialize */
memset(out_intvl, 0, sizeof(*out_intvl));
if (arg_intvl == (char *) NULL) {
printf("error: time-interval value is not specified\n");
return BCME_BADARG;
}
errno = 0;
memset(&src_data_intvl, 0, sizeof(src_data_intvl));
/* time interval e.g. 10ns */
/* get the number */
p_end = NULL;
src_data_intvl.intvl = htol32(strtoul(arg_intvl, &p_end, 10));
if (errno) {
printf("error: invalid time interval (errno=%d)\n", errno);
return BCME_BADARG;
}
/* get time-unit */
src_data_intvl.tmu = WL_PROXD_TMU_TU; /* default */
if (*p_end != '\0') {
if (!ftm_get_tmu_from_str(p_end, &src_data_intvl.tmu)) {
printf("error: invalid time-unit %s\n", p_end);
return BCME_BADARG;
}
}
src_data_intvl.tmu = htol16(src_data_intvl.tmu);
/* return to caller */
memcpy(out_intvl, &src_data_intvl, sizeof(*out_intvl));
return BCME_OK;
}
/*
* parse and pack 'intvl' param-value from a command-line argument
* Input:
* arg_tpk: tpk param-value argument string
* out_tpk: buffer to store tpk and mac address
*/
static int
ftm_config_parse_tpk_peer(char *arg_tpk, wl_proxd_tpk_t *out_tpk)
{
wl_proxd_tpk_t src_data_tpk;
/* initialize */
memset(out_tpk, 0, sizeof(*out_tpk));
if (arg_tpk == (char *) NULL) {
printf("error: tpk value is not specified\n");
return BCME_BADARG;
}
errno = 0;
memset(&src_data_tpk, 0, sizeof(src_data_tpk));
/* get link mac address */
if (!wl_ether_atoe(arg_tpk, &src_data_tpk.peer))
return BCME_USAGE_ERROR;
/* get TPK */
if (*arg_tpk) {
memcpy(&src_data_tpk.peer, arg_tpk, ETHER_ADDR_LEN);
}
/* return to caller */
memcpy(out_tpk, &src_data_tpk, sizeof(*out_tpk));
return BCME_OK;
}
/*
* parse and pack one 'config avail slot' param-value from a command-line
* Input:
* arg_slot: 'slot' param-value argument string
* in "channel:start-tmu:duration-tmu" format
* out_avail_slot: buffer to store the result
*/
static int
ftm_config_avail_parse_slot(char *arg_slot, wl_proxd_time_slot_t *out_avail_slot)
{
int arg_idx;
const char *tmp_start, *tmp_end;
char tmpbuf[128];
int len;
int status = BCME_OK;
if (arg_slot == (char *) NULL) {
printf("error: slot value is not specified\n");
return BCME_BADARG;
}
/* parse channel:start-tmu:duration-tmu */
tmp_start = arg_slot;
for (arg_idx = 0; arg_idx < 3; arg_idx++) {
tmp_end = strchr(tmp_start, ':');
if (tmp_end == NULL) {
if (arg_idx != 2 || *tmp_start == '\0') {
status = BCME_BADARG;
goto done;
}
/* for last 'duration intvl' */
tmp_end = tmp_start + strlen(tmp_start);
}
/* create a temp null-terminated substring */
if ((len = tmp_end - tmp_start) >= (int) sizeof(tmpbuf)) {
status = BCME_BADARG;
goto done;
}
memcpy(tmpbuf, tmp_start, len);
tmpbuf[len] = '\0'; /* null-terminate */
if (arg_idx == 0)
status = ftm_config_parse_channel(tmpbuf, &out_avail_slot->chanspec);
else if (arg_idx == 1)
status = ftm_config_parse_intvl(tmpbuf, &out_avail_slot->start);
else /* arg_idx == 2 */
status = ftm_config_parse_intvl(tmpbuf, &out_avail_slot->duration);
if (status != BCME_OK)
goto done;
/* continue on next element */
tmp_start = tmp_end + 1;
}
/* make sure no string beyond 'channel:start-tmu:duration-tmu' */
if (*tmp_end != '\0') {
printf("error: invalid 'slot' value '%s'\n", tmp_end);
status = BCME_BADARG;
}
done:
if (status == BCME_BADARG)
printf("error: invalid value for slot\n");
return status;
}
/*
* parse and pack 'config avail time-ref' param-value from a command-line
* Input:
* arg_tref: 'time-ref' param-value argument string
* in "none|dev-tsf|nan-dw|tbtt" format
* out_tref: buffer to store the result
*/
static int
ftm_config_avail_parse_tref(char *arg_tref, wl_proxd_time_ref_t *out_tref)
{
wl_proxd_time_ref_t src_data_tref;
const ftm_strmap_entry_t *p_entry;
if (arg_tref == (char *) NULL) {
printf("error: time-ref value is not specified\n");
return BCME_BADARG;
}
/* loop up */
p_entry = ftm_get_strmap_info_strkey(arg_tref, &ftm_avail_timeref_value_loginfo[0],
ARRAYSIZE(ftm_avail_timeref_value_loginfo));
if (p_entry)
src_data_tref = p_entry->id;
else {
printf("error: invalid time-ref value\n");
return BCME_BADARG;
}
*out_tref = htol16((uint16) src_data_tref);
return BCME_OK;
}
#define FTM_AVAIL_MAX_SLOTS 32 /* also in pdftmpvt.h */
/*
* parse and pack a list of 'slot-value' for availability
* Input:
* argv -- point to something like "ch1:start-tmu1:duration-tmu1
* ch2:start-tmu2:duration-tmu2 ..."
*/
static int
ftm_config_avail_parse_all_slots(char **argv, wl_proxd_avail_t *avail, uint16 *out_num_slots)
{
int err = BCME_OK;
uint16 num_slots;
wl_proxd_time_slot_t *avail_slot;
*out_num_slots = 0;
num_slots = 0;
avail_slot = WL_PROXD_AVAIL_TIMESLOTS(avail);
while (*argv != NULL) { /* parse each slot-value */
if (num_slots >= FTM_AVAIL_MAX_SLOTS) {
printf("error: number of slots exceed the limit (%d)\n",
FTM_AVAIL_MAX_SLOTS);
err = BCME_BADARG; /* too many time-slots */
goto done;
}
/* parse channel:start-tmu:duration-tmu */
err = ftm_config_avail_parse_slot(*argv, avail_slot);
if (err != BCME_OK)
goto done;
num_slots++;
avail_slot++;
++argv; /* continue on next slot-value */
}
if (num_slots == 0) {
printf("error: slot-value is not specified\n");
err = BCME_BADARG;
goto done;
}
*out_num_slots = num_slots;
done:
return err;
}
/*
* allocate the availability info
* if succeeds, an avail-buffer with 'max_slots' will be allocated
*/
static int
ftm_config_avail_alloc(wl_proxd_avail_t **out_avail)
{
uint16 bufsize;
wl_proxd_avail_t *avail;
/* init */
*out_avail = (wl_proxd_avail_t *) NULL;
bufsize = WL_PROXD_AVAIL_SIZE(avail, FTM_AVAIL_MAX_SLOTS);
avail = calloc(1, bufsize);
if (avail == NULL) {
printf("error: failed to allocate %d bytes of memory for avail\n",
bufsize);
return BCME_NOMEM;
}
/* initialize */
avail->flags = htol16(WL_PROXD_AVAIL_NONE); /* don't care, for query only */
avail->time_ref = htol16(WL_PROXD_TREF_NONE);
avail->max_slots = htol16(FTM_AVAIL_MAX_SLOTS);
avail->num_slots = htol16(0);
#define WLU_PROXD_AVAIL_REPEAT_TU 512 /* default interval */
avail->repeat.intvl = htol32(WLU_PROXD_AVAIL_REPEAT_TU);
avail->repeat.tmu = htol16(WL_PROXD_TMU_TU);
*out_avail = avail;
return BCME_OK;
}
/* Support AVAIL24 */
/*
* allocate and convert the availability info to AVAIL24 format
* if succeeds, an avail-buffer with 'in_avail_num_slots' time slot in AVAIL24
* format will be allocated.
*/
static int
ftm_config_avail_to_avail24(wl_proxd_avail_t *in_avail,
uint16 in_avail_num_slots, wl_proxd_avail24_t **out_avail)
{
uint16 bufsize;
wl_proxd_avail24_t *avail24 = NULL;
wl_proxd_time_slot_t *avail_slot, *avail24_slot;
/* init */
*out_avail = (wl_proxd_avail24_t *) NULL;
bufsize = WL_PROXD_AVAIL24_SIZE(avail24, in_avail_num_slots);
avail24 = calloc(1, bufsize);
if (avail24 == NULL) {
printf("error: failed to allocate %d bytes of memory for avail\n",
bufsize);
return BCME_NOMEM;
}
/* convert the header */
avail24->flags = in_avail->flags;
avail24->time_ref = in_avail->time_ref;
avail24->max_slots = htol16(in_avail_num_slots); /* don't care, for query only */
avail24->num_slots = avail24->max_slots;
avail24->repeat.intvl = in_avail->repeat.intvl;
avail24->repeat.tmu = in_avail->repeat.tmu;
/* convert time-slot */
avail_slot = WL_PROXD_AVAIL_TIMESLOTS(in_avail);
avail24_slot = WL_PROXD_AVAIL24_TIMESLOTS(avail24); /* &avail24->ts0[0]; */
memcpy(avail24_slot, avail_slot, in_avail_num_slots * sizeof(avail24->ts0[0]));
*out_avail = avail24;
return BCME_OK;
}
/*
* parse cmd-line for 'wl proxd ftm [<session-id>] config avail' command
* { [ftm-ref] none |
* time-ref dev-tsf|nan-adv|tbtt repeat repeat-tmu slot {channel:start-tmu:duration-tmu}+ }
* if succeeds, an avail info is allocated (data is packed) and returned.
* Also, number of time-slots associated with this buffer will be returned
* in 'out_num_slots'.
*/
static int
ftm_pack_config_avail_from_cmdarg(char **argv,
wl_proxd_avail_t **out_avail, uint16 *out_num_slots)
{
wl_proxd_avail_t *avail = NULL;
wl_proxd_time_ref_t time_ref;
uint16 num_slots = 0;
int err = BCME_OK;
/* init */
*out_avail = NULL;
*out_num_slots = 0;
/* check if user provides <param-name><param-value> for 'config avail' command */
if (*argv == NULL) {
err = BCME_USAGE_ERROR;
goto done;
}
/* allocate a buffer for parsing cmd-args */
err = ftm_config_avail_alloc(&avail);
if (err != BCME_OK)
goto done;
/* parse input arguments */
num_slots = 0;
time_ref = htol16(WL_PROXD_TREF_NONE); /* default */
while (*argv != NULL) {
if (stricmp(*argv, "none") == 0) {
time_ref = htol16(WL_PROXD_TREF_NONE);
}
else if (stricmp(*argv, "time-ref") == 0) {
++argv; /* advance to 'param-value' */
err = ftm_config_avail_parse_tref(*argv, &time_ref);
if (err != BCME_OK)
goto done;
}
else if (stricmp(*argv, "repeat") == 0) {
++argv; /* advance to 'param-value' */
err = ftm_config_parse_intvl(*argv, &avail->repeat);
if (err != BCME_OK)
goto done;
}
else if (stricmp(*argv, "slot") == 0) {
if (time_ref == htol16(WL_PROXD_TREF_NONE)) {
printf("error: time-ref is missing or invalid for slot\n");
err = BCME_BADARG;
goto done;
}
++argv; /* advance to 'param-value' */
err = ftm_config_avail_parse_all_slots(argv, avail, &num_slots);
if (err != BCME_OK)
goto done;
break; /* done parsing */
}
else {
printf("error: invalid param-name (%s)\n", *argv);
err = BCME_USAGE_ERROR; /* param-name is not specified */
goto done;
}
++argv; /* continue on next 'param-name' */
}
avail->time_ref = time_ref;
avail->num_slots = htol16(num_slots);
*out_avail = avail;
*out_num_slots = num_slots;
avail = (wl_proxd_avail_t *) NULL;
done:
if (err != BCME_OK) {
if (avail) /* cleanup */
free(avail);
}
return err;
}
/*
* handle 'wl proxd ftm [<session-id>] config avail
* { [ftm-ref] none |
* time-ref dev-tsf|nan-adv|tbtt repeat repeat-tmu slot {channel:start-tmu:duration-tmu}+ }
* parse cmd-line, setup local/peer(method/sessions) availability TLVs in caller
* provided buffer and adjusted-buffer-space if applies.
* Note, input '<session-id>' is used to determine if config-avail is
* for 'local' or 'peer'.
*
* This function is invoked from ftm_subcmd_config().
*/
static int
ftm_do_config_avail_iovar(void *wl, wl_proxd_iov_t *p_proxd_iov, uint16 proxd_iovsize,
uint16 tlvid, void *avail, int avail_size)
{
int err = BCME_OK;
uint16 bufsize;
wl_proxd_tlv_t *p_tlv;
uint16 buf_space_left;
uint16 all_tlvsize;
/* setup TLVs */
bufsize = proxd_iovsize - WL_PROXD_IOV_HDR_SIZE; /* adjust available size for TLVs */
p_tlv = &p_proxd_iov->tlvs[0];
/* TLV buffer starts with a full size, will decrement for each packed TLV */
buf_space_left = bufsize;
err = bcm_pack_xtlv_entry((uint8 **) &p_tlv, &buf_space_left,
tlvid, avail_size, (void *) avail,
BCM_XTLV_OPTION_ALIGN32);
if (err != BCME_OK) {
printf("%s: failed to pack TLVs for availability, status=%d\n",
__FUNCTION__, err);
goto done;
}
/* update the iov header, set len to include all TLVs + header */
all_tlvsize = (bufsize - buf_space_left);
p_proxd_iov->len = htol16(all_tlvsize + WL_PROXD_IOV_HDR_SIZE);
err = wlu_var_setbuf(wl, "proxd", p_proxd_iov,
all_tlvsize + WL_PROXD_IOV_HDR_SIZE);
done:
return err;
}
static int
ftm_handle_config_avail(void *wl, wl_proxd_iov_t *p_proxd_iov, uint16 proxd_iovsize,
wl_proxd_session_id_t session_id, char **argv)
{
int err = BCME_OK;
wl_proxd_avail_t *avail = NULL;
wl_proxd_avail24_t *avail24 = NULL;
uint16 num_slots;
int avail_size;
UNUSED_PARAMETER(session_id);
/* parse cmd line and alloc/pack the avail info */
err = ftm_pack_config_avail_from_cmdarg(argv,
&avail, &num_slots);
if (err != BCME_OK)
goto done;
/* pack and request to config the avail using the latest AVAIL if supported */
err = ftm_is_tlv_id_supported(wl, WL_PROXD_TLV_ID_AVAIL);
if (err == BCME_OK) {
/* adjust size based on num-slots available */
avail_size = WL_PROXD_AVAIL_SIZE(avail, num_slots);
err = ftm_do_config_avail_iovar(wl, p_proxd_iov, proxd_iovsize,
WL_PROXD_TLV_ID_AVAIL, (void *) avail, avail_size);
goto done;
}
/* try AVAIL24 */
/* convert to AVAIL24 format */
err = ftm_config_avail_to_avail24(avail,
num_slots, &avail24);
if (err != BCME_OK)
goto done;
/* adjust size based on num-slots available */
avail_size = WL_PROXD_AVAIL24_SIZE(avail24, num_slots);
err = ftm_do_config_avail_iovar(wl, p_proxd_iov, proxd_iovsize,
WL_PROXD_TLV_ID_AVAIL24, (void *) avail24, avail_size);
done:
if (avail) /* clean up */
free(avail);
if (avail24)
free(avail24);
return err;
}
/* proxd ftm config-category definition */
typedef enum {
FTM_CONFIG_CAT_GENERAL = 1, /* generial configuration */
FTM_CONFIG_CAT_OPTIONS = 2, /* 'config options' */
FTM_CONFIG_CAT_AVAIL = 3, /* 'config avail' */
FTM_CONFIG_CAT_SESSION_OPTIONS = 4
} ftm_config_category_t;
/*
* parse the config-category from a command-line
* Input:
* arg_type: a config-category string after 'wl proxd ftm config' from the command-line
*/
static ftm_config_category_t
ftm_parse_config_category(char *arg_category)
{
if (stricmp(arg_category, "options") == 0)
return FTM_CONFIG_CAT_OPTIONS;
if (stricmp(arg_category, "avail") == 0)
return FTM_CONFIG_CAT_AVAIL;
if (stricmp(arg_category, "session-options") == 0)
return FTM_CONFIG_CAT_SESSION_OPTIONS;
return FTM_CONFIG_CAT_GENERAL;
}
/*
* 'wl proxd ftm config' handler for general-configuration:
* wl proxd ftm [<session-id>] config [<param-name> <param-value>]+
*/
static int
ftm_handle_config_general(wl_proxd_session_id_t session_id, char **argv,
wl_proxd_tlv_t **p_tlv, uint16 *p_buf_space_left)
{
int status = BCME_OK;
/* data from command line as 'src' */
unsigned long int tmp_data_ul;
uint8 src_data_uint8;
uint16 src_data_uint16;
uint32 src_data_uint32;
struct ether_addr src_data_mac = ether_null;
wl_proxd_intvl_t src_data_intvl;
wl_proxd_tpk_t src_data_tpk;
void *p_src_data;
uint16 src_data_size; /* size of data pointed by p_src_data as 'source' */
const ftm_config_param_info_t *p_config_param_info;
/* parse the cmd-line, scan thru all <param-name> <param-value> */
while (*argv != NULL) {
/* look up 'config-param-info' based on 'param-name' */
p_config_param_info = ftm_get_config_param_info(*argv, session_id);
if (p_config_param_info == (ftm_config_param_info_t *) NULL) {
printf("error: invalid param-name (%s)\n", *argv);
status = BCME_USAGE_ERROR; /* param-name is not specified */
break;
}
/* parse 'param-value' */
if (*(argv + 1) == NULL) {
printf("error: invalid param-value\n");
status = BCME_USAGE_ERROR; /* param-value is not specified */
break;
}
++argv;
/* parse param-value, setup tlv-data */
p_src_data = (void *) NULL;
src_data_size = 0;
switch (p_config_param_info->tlvid) {
case WL_PROXD_TLV_ID_BSS_INDEX: /* uint8 */
case WL_PROXD_TLV_ID_NAN_MAP_ID:
case WL_PROXD_TLV_ID_FTM_REQ_RETRIES:
case WL_PROXD_TLV_ID_FTM_RETRIES:
src_data_uint8 = atoi(*argv);
p_src_data = (void *) &src_data_uint8;
src_data_size = sizeof(uint8);
break;
case WL_PROXD_TLV_ID_BURST_NUM_FTM: /* uint16 */
case WL_PROXD_TLV_ID_NUM_BURST:
case WL_PROXD_TLV_ID_RX_MAX_BURST:
if ((status = ftm_config_parse_ul(argv, p_config_param_info,
(unsigned long int) 0, (unsigned long int) 0xffff,
&tmp_data_ul)) != BCME_OK)
break;
src_data_uint16 = htol16((uint16) tmp_data_ul);
p_src_data = (void *) &src_data_uint16;
src_data_size = sizeof(uint16);
break;
case WL_PROXD_TLV_ID_TX_POWER: /* uint32 */
case WL_PROXD_TLV_ID_RATESPEC:
case WL_PROXD_TLV_ID_EVENT_MASK: /* wl_proxd_event_mask_t/uint32 */
case WL_PROXD_TLV_ID_DEBUG_MASK: /* allow in 0x######## format */
if ((status = ftm_config_parse_ul(argv, p_config_param_info,
(unsigned long int) 0, (unsigned long int) 0xffffffff,
&tmp_data_ul)) != BCME_OK)
break;
/* get the bitmask */
src_data_uint32 = htol32((uint32) tmp_data_ul);
p_src_data = &src_data_uint32;
src_data_size = sizeof(uint32);
break;
case WL_PROXD_TLV_ID_CHANSPEC: /* chanspec_t --> 32bit */
status = ftm_config_parse_channel(*argv, &src_data_uint32);
if (status == BCME_OK) {
p_src_data = (void *) &src_data_uint32;
src_data_size = sizeof(uint32);
}
break;
case WL_PROXD_TLV_ID_BSSID: /* mac address */
case WL_PROXD_TLV_ID_PEER_MAC:
case WL_PROXD_TLV_ID_DEV_ADDR:
src_data_mac = ether_null;
if (!wl_ether_atoe(*argv, &src_data_mac)) {
printf("error: invalid MAC address parameter\n");
status = BCME_USAGE_ERROR;
break;
}
p_src_data = &src_data_mac;
src_data_size = sizeof(src_data_mac);
break;
case WL_PROXD_TLV_ID_BURST_DURATION: /* wl_proxd_intvl_t */
case WL_PROXD_TLV_ID_BURST_PERIOD:
case WL_PROXD_TLV_ID_BURST_FTM_SEP:
case WL_PROXD_TLV_ID_BURST_TIMEOUT:
case WL_PROXD_TLV_ID_INIT_DELAY:
status = ftm_config_parse_intvl(*argv, &src_data_intvl);
if (status == BCME_OK) {
p_src_data = (void *) &src_data_intvl;
src_data_size = sizeof(src_data_intvl);
}
break;
case WL_PROXD_TLV_ID_TPK:
status = ftm_config_parse_tpk_peer(*argv, &src_data_tpk);
if (status == BCME_OK) {
p_src_data = (void *) &src_data_tpk;
src_data_size = sizeof(src_data_tpk);
}
break;
default:
/* not supported now */
status = BCME_USAGE_ERROR;
break;
}
if (status != BCME_OK)
break; /* abort */
status = bcm_pack_xtlv_entry((uint8 **) p_tlv, p_buf_space_left,
p_config_param_info->tlvid, src_data_size, p_src_data,
BCM_XTLV_OPTION_ALIGN32);
if (status != BCME_OK)
{
#ifdef WL_FTM_DEBUG
printf("%s: bcm_pack_xltv_entry() failed, status=%d\n",
__FUNCTION__, status);
#endif /* WL_FTM_DEBUG */
break; /* abort */
}
argv++; /* continue on next <param-name><param-value> */
}
return status;
}
/*
* 'wl proxd ftm config' handler, there are two formats:
* For options/flags config, use
* wl proxd ftm [<session-id>] config options { [+|-]<param-value> }+
* for non-options/flags config, use
* wl proxd ftm [<session-id>] config [<param-name> <param-value>]+
*/
static int
ftm_subcmd_config(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
ftm_config_category_t category;
uint16 proxd_iovsize;
wl_proxd_iov_t *p_proxd_iov;
int status = BCME_OK;
uint16 bufsize;
wl_proxd_tlv_t *p_tlv;
uint16 buf_space_left;
uint16 all_tlvsize;
if (*argv == NULL) {
printf("error: config command requires parameters\n");
/* display 'proxd -h ftm config' helpmsg */
ftm_display_config_help();
return BCME_OK; /* no need to show 'proxd'-level help */
}
/* allocate a buffer for proxd-ftm config via 'set' iovar */
p_proxd_iov = ftm_alloc_getset_buf(method, session_id,
p_subcmd_info->cmdid, FTM_IOC_BUFSZ, &proxd_iovsize);
if (p_proxd_iov == (wl_proxd_iov_t *) NULL)
return BCME_NOMEM;
/* setup TLVs */
bufsize = proxd_iovsize - WL_PROXD_IOV_HDR_SIZE; /* adjust available size for TLVs */
p_tlv = &p_proxd_iov->tlvs[0];
/* TLV buffer starts with a full size, will decrement for each packed TLV */
buf_space_left = bufsize;
/* parse the cmd-line, get the config-category and dispatch to the handler */
/* to parse the parameters based on the 'config-category' */
category = ftm_parse_config_category(*argv);
if (category == FTM_CONFIG_CAT_OPTIONS) {
/* for 'wl proxd ftm [session-id] config options' */
/* dispatch to setup TLVs for method/session options/flags */
status = ftm_handle_config_options(session_id, ++argv, &p_tlv,
&buf_space_left, session_id != WL_PROXD_SESSION_ID_GLOBAL ? FALSE : TRUE);
} else if (category == FTM_CONFIG_CAT_SESSION_OPTIONS) {
status = ftm_handle_config_options(session_id, ++argv, &p_tlv,
&buf_space_left, FALSE);
} else if (category == FTM_CONFIG_CAT_AVAIL) {
status = ftm_handle_config_avail(wl, p_proxd_iov, proxd_iovsize,
session_id, ++argv);
}
else
status = ftm_handle_config_general(session_id, argv, &p_tlv,
&buf_space_left);
if (status == BCME_OK && category != FTM_CONFIG_CAT_AVAIL) {
/* update the iov header, set len to include all TLVs + header */
all_tlvsize = (bufsize - buf_space_left);
p_proxd_iov->len = htol16(all_tlvsize + WL_PROXD_IOV_HDR_SIZE);
status = wlu_var_setbuf(wl, "proxd", p_proxd_iov,
all_tlvsize + WL_PROXD_IOV_HDR_SIZE);
}
if (status == BCME_USAGE_ERROR) {
if (category == FTM_CONFIG_CAT_OPTIONS)
ftm_display_config_options_help();
else if (category == FTM_CONFIG_CAT_AVAIL)
ftm_display_config_avail_help();
else
ftm_display_config_help();
status = BCME_OK; /* reset to avoid showing 'proxd'-level help */
}
/* clean up */
free(p_proxd_iov);
#ifdef WL_FTM_DEBUG
if (status != BCME_OK)
printf("error: exit %s, status = %d\n", __FUNCTION__, status);
#endif /* WL_FTM_DEBUG */
return status;
}
static void
ftm_display_cmd_help(const ftm_subcmd_info_t *p_subcmd_info,
const char *cmd_params)
{
if (p_subcmd_info == (ftm_subcmd_info_t *) NULL)
return;
if (p_subcmd_info->helpmsg == (char *) NULL)
return;
/* print help messages for a specific FTM sub-command */
printf("\n\t%s\n", p_subcmd_info->helpmsg);
/* display cmd usage (these commands require no parameters) */
printf("\tUsage: wl proxd ftm ");
if (p_subcmd_info->cmdflag & FTM_SUBCMD_FLAG_SESSION) {
if (p_subcmd_info->cmdflag & FTM_SUBCMD_FLAG_METHOD)
printf("[<session-id>] ");
else
printf("<session-id> ");
}
printf("%s%s\n\n",
p_subcmd_info->name, cmd_params ? cmd_params : "");
}
/*
* pack tlvs for 'wl proxd ftm start-ranging [-d] <sid1> <sid2> ...'
* parse cmd-line, setup TLVs in caller provided buffer,
* adjusted buffer-space if applies.
* This function is invoked from ftm_subcmd_start_ranging().
*/
static int
ftm_pack_sids_from_cmdarg(char **argv,
wl_proxd_tlv_t **p_tlv, uint16 *p_buf_space_left)
{
char **tmp_argv;
uint16 num_sids;
int err = BCME_OK;
uint16 ranging_sids_size;
wl_proxd_session_id_list_t *ranging_sids = NULL;
wl_proxd_session_id_t sid;
uint16 count;
/* figout out number of session-id from the input */
tmp_argv = argv;
num_sids = 0;
while (*tmp_argv != NULL) {
tmp_argv++;
num_sids++;
}
if (num_sids == 0) {
err = BCME_USAGE_ERROR;
goto done;
}
/* allocate a temp buffer for parsing cmd-args */
ranging_sids_size = OFFSETOF(wl_proxd_session_id_list_t, ids) +
num_sids * sizeof(wl_proxd_session_id_t);
ranging_sids = calloc(1, ranging_sids_size);
if (ranging_sids == (wl_proxd_session_id_list_t *) NULL) {
printf("error: failed to allocate %d bytes of memory for ranging\n",
ranging_sids_size);
err = BCME_NOMEM;
goto done;
}
/* get session-ids followed 'wl proxd ftm start-ranging [-d]' */
count = 0;
while (*argv != NULL) {
sid = (uint16) atoi(*argv);
ranging_sids->ids[count++] = htol16(sid);
argv++; /* continue on next session-id */
}
ranging_sids->num_ids = htol16(num_sids);
err = bcm_pack_xtlv_entry((uint8 **) p_tlv, p_buf_space_left,
WL_PROXD_TLV_ID_SESSION_ID_LIST, ranging_sids_size,
(uint8 *)ranging_sids, BCM_XTLV_OPTION_ALIGN32);
if (err != BCME_OK) {
printf("%s: failed to pack ranging-ids in xtlv, err=%d\n",
__FUNCTION__, err);
goto done;
}
done:
/* clean up */
if (ranging_sids)
free(ranging_sids);
return err;
}
/*
* pack tlvs for 'wl proxd ftm start-ranging [-d] <sid1> <sid2> ...'
* parse cmd-line, setup TLVs in caller provided buffer,
* adjusted buffer-space if applies.
* This function is invoked from ftm_subcmd_start_ranging().
*/
static int
ftm_pack_ranging_config_from_cmdarg(char **argv,
wl_proxd_tlv_t **p_tlv, uint16 *p_buf_space_left)
{
int err = BCME_OK;
wl_proxd_ranging_flags_t flags;
wl_proxd_ranging_flags_t flags_mask;
/* parse the ranging-flags '-d' followed 'wl proxd ftm start-ranging' if available */
flags = WL_PROXD_RANGING_FLAG_NONE;
while (*argv != NULL) {
if (stricmp(*argv, "-d") != 0)
break; /* skip to handle 'sids' arguments */
flags = WL_PROXD_RANGING_FLAG_DEL_SESSIONS_ON_STOP;
argv++; /* continue on next session-id */
}
/* pack ranging-flags/mask in xTLVs if provided */
if (flags != WL_PROXD_RANGING_FLAG_NONE) {
/* setup ranging flags TLV */
err = bcm_pack_xtlv_entry((uint8 **) p_tlv, p_buf_space_left,
WL_PROXD_TLV_ID_RANGING_FLAGS,
sizeof(uint16), (uint8 *)&flags, BCM_XTLV_OPTION_ALIGN32);
if (err != BCME_OK) {
printf("%s: failed to pack ranging-flags in xtlv, err=%d\n",
__FUNCTION__, err);
goto done; /* abort */
}
/* setup ranging flags_mask TLV */
flags_mask = WL_PROXD_RANGING_FLAG_ALL;
err = bcm_pack_xtlv_entry((uint8 **) p_tlv, p_buf_space_left,
WL_PROXD_TLV_ID_RANGING_FLAGS_MASK,
sizeof(uint16), (uint8 *)&flags_mask, BCM_XTLV_OPTION_ALIGN32);
if (err != BCME_OK) {
printf("%s: failed to pack ranging flags_mask in xtlv, err=%d\n",
__FUNCTION__, err);
goto done; /* abort */
}
}
/* parse the 'sids' followed 'wl proxd ftm start-ranging [-d]' and
* pack the parameters in xTLVs if available
*/
err = ftm_pack_sids_from_cmdarg(argv, p_tlv, p_buf_space_left);
done:
if (err != BCME_OK)
printf("%s failed, err = %d\n",
__FUNCTION__, err);
return err;
}
/*
* 'wl proxd ftm start-ranging' handler
* wl proxd ftm start-ranging [-d] <sid1> <sid2> ...
*/
static int
ftm_subcmd_start_ranging(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
wl_proxd_iov_t *p_proxd_iov = NULL;
uint16 proxd_iovsize;
uint16 bufsize;
wl_proxd_tlv_t *p_tlv;
uint16 buf_space_left;
int err = BCME_OK;
uint16 all_tlvsize;
UNUSED_PARAMETER(wl);
/* this should apply to a method command */
if (*argv == NULL || session_id != WL_PROXD_SESSION_ID_GLOBAL) {
printf("error: start-ranging command requires parameters\n");
err = BCME_USAGE_ERROR;
goto done;
}
/* allocate a buffer for proxd-ftm config via 'set' iovar */
p_proxd_iov = ftm_alloc_getset_buf(method, session_id,
p_subcmd_info->cmdid, FTM_IOC_BUFSZ, &proxd_iovsize);
if (p_proxd_iov == (wl_proxd_iov_t *) NULL) {
err = BCME_NOMEM;
goto done;
}
/* setup TLVs */
bufsize = proxd_iovsize - WL_PROXD_IOV_HDR_SIZE; /* adjust available size for TLVs */
p_tlv = &p_proxd_iov->tlvs[0];
/* TLV buffer starts with a full size, will decrement for each packed TLV */
buf_space_left = bufsize;
/* parse the cmd-line, pack the parameters in TLVs */
err = ftm_pack_ranging_config_from_cmdarg(argv, &p_tlv,
&buf_space_left);
if (err != BCME_OK)
goto done;
/* update the iov header, set len to include all TLVs + header */
all_tlvsize = (bufsize - buf_space_left);
p_proxd_iov->len = htol16(all_tlvsize + WL_PROXD_IOV_HDR_SIZE);
err = wlu_var_setbuf(wl, "proxd", p_proxd_iov,
all_tlvsize + WL_PROXD_IOV_HDR_SIZE);
done:
/* clean up */
if (p_proxd_iov)
free(p_proxd_iov);
if (err == BCME_USAGE_ERROR) {
/* display 'proxd -h ftm' helpmsg */
ftm_display_cmd_help(p_subcmd_info, "[-d] <sid1> <sid2> ...");
err = BCME_OK; /* reset to avoid showing 'proxd'-level help */
}
return err;
}
/*
* 'wl proxd ftm stop-ranging' handler,
* wl proxd ftm stop-ranging
*/
static int
ftm_subcmd_stop_ranging(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
/* this should apply to a method command */
if (session_id != WL_PROXD_SESSION_ID_GLOBAL) {
printf("error: no session-id is allowed for stop-ranging\n");
/* display 'proxd -h ftm stop-ranging ' helpmsg */
ftm_display_cmd_help(p_subcmd_info, "");
return BCME_OK; /* no need to show 'proxd'-level help */
}
/* issue an iovar call */
return ftm_subcmd_setiov_no_tlv(wl, p_subcmd_info, method, session_id, argv);
}
/*
* display help-messages for 'wl proxd -h ftm'
*/
static void
ftm_display_method_help()
{
int i;
int max_cmdname_len = 20;
const ftm_subcmd_info_t *p_subcmd_info;
/* a header */
printf("\n\tProximity Detection using FTM\n");
printf("\tUsage: wl proxd ftm [<session-id>] <cmd> [<param-name> <param-value>]*\n");
printf("\t\t<session-id>: specify a session; If omitted, <cmd> applies to FTM method\n");
printf("\t\t<cmd>: specify a command from the following list,\n");
/* show the command list and the help messages for each FTM command */
p_subcmd_info = &ftm_cmdlist[0];
for (i = 0; i < (int) ARRAYSIZE(ftm_cmdlist); i++) {
printf("\t\t %*s: %s\n", max_cmdname_len, p_subcmd_info->name,
p_subcmd_info->helpmsg);
p_subcmd_info++;
}
printf("\t\t<param-name> <param-value>: <cmd>-specific parameters\n\n");
printf("\t\ttype 'wl proxd -h ftm config' for configuration command usage.\n");
printf("\t\ttype 'wl proxd -h ftm config options' "
"for options-configuration command usage.\n");
printf("\t\ttype 'wl proxd -h ftm config avail' "
"for availability-configuration command usage.\n");
printf("\t\ttype 'wl proxd -h ftm <cmd>' for others command usage.\n\n");
/* show examples */
printf("\tExample: wl proxd ftm enable\n\n");
return;
}
/*
* display help-messages for 'wl proxd -h ftm config'
*/
static void
ftm_display_config_help()
{
int i;
int max_param_name_len = 20;
const ftm_config_param_info_t *p_config_param_info;
/* a header */
printf("\n\tConfigure Proximity Detection using FTM\n");
printf("\tUsage: wl proxd ftm [<session-id>] config { <param-name> <param-value> }+ \n");
printf("\t\t<session-id>: specify a session id; If omitted, configure global items\n");
/* print helpmsg for each config-item */
printf("\t\t<param-name> <param-value>: configuration parameters from the following\n");
p_config_param_info = &ftm_config_param_info[0];
for (i = 0; i < (int) ARRAYSIZE(ftm_config_param_info); i++) {
printf("\t\t %*s: %s\n", max_param_name_len, p_config_param_info->name,
p_config_param_info->name_helpmsg);
p_config_param_info++;
}
/* show examples */
printf("\n\tExample: wl proxd ftm config retries 10\n");
printf("\t wl proxd ftm 1 config retries 10\n");
}
/*
* display help-messages for 'wl proxd -h ftm config options'
*/
static void
ftm_display_config_options_help()
{
int i;
int max_option_name_len = 20;
const ftm_config_options_info_t *p_config_options_info;
/* a header */
printf("\n\tConfigure-Options Proximity Detection using FTM\n");
printf("\tUsage: wl proxd ftm [<session-id>] config options { [+|-]<param-value> }+ \n");
printf("\t\t<session-id>: specify a session id; If omitted, set the global options\n");
printf("\t\t+|- prefix: to add or remove an option\n");
printf("\t\t<param-value>: specify an option\n");
/* print helpmsg for each global option flag */
printf("\t\t\tConfigurable options for a FTM method:\n");
p_config_options_info = &ftm_method_options_info[0];
for (i = 0; i < (int) ARRAYSIZE(ftm_method_options_info); i++) {
printf("\t\t %*s (0x%08x): %s\n", max_option_name_len,
p_config_options_info->param_value_str,
p_config_options_info->flags, p_config_options_info->helpmsg);
p_config_options_info++;
}
/* print helpmsg for each session option flag */
printf("\n\t\t\tConfigurable options for a specific session:\n");
p_config_options_info = &ftm_session_options_info[0];
for (i = 0; i < (int) ARRAYSIZE(ftm_session_options_info); i++) {
printf("\t\t %*s (0x%08x): %s\n", max_option_name_len,
p_config_options_info->param_value_str,
p_config_options_info->flags, p_config_options_info->helpmsg);
p_config_options_info++;
}
/* show examples */
printf("\n\tExample: wl proxd ftm config options +rx-enable\n");
printf("\t wl proxd ftm config options +0x00000001\n");
printf("\t wl proxd ftm 1 config options +rx-auto-burst -rtt-detail\n\n");
return;
}
/*
* display help-messages for 'wl proxd -h ftm config avail'
*/
static void
ftm_display_config_avail_help()
{
/* a header */
printf("\n\tConfigure-availability Proximity Detection using FTM\n");
printf("\t\tUsage: wl proxd ftm [<session-id>] config avail\n");
printf("\t\t { [time-ref] none |\n");
printf("\t\t time-ref <timeref-value> repeat <repeat-tmu> slot {<slot-value>}+ }\n");
printf("\t\t<session-id>: a session id; If omitted, set the local availability\n");
printf("\t\t otherwise, set the peer availability\n");
printf("\t\tnone or time-ref none: to clear availability\n");
printf("\t\t<timeref-value>: a timer reference. Possible values are:\n");
printf("\t\t dev-tsf | nan-dw | tbtt\n");
printf("\t\t<repeat-tmu>: repeat period in time-interval format\n");
printf("\t\t<slot-value>: a time slot in channel:start-tmu:duration-tmu\n");
printf("\t\t channel -- a channel (see 'wl chanspec')\n");
printf("\t\t start-tmu -- start time in time-interval format\n");
printf("\t\t (a number followed by a time unit)\n");
printf("\t\t duration-tmu -- duration in time-interval format\n");
printf("\t\t Time uints are:\n");
printf("\t\t s (seconds) | ms (milliseconds) | us (microseconds)\n");
printf("\t\t ns (nanoseconds) | ps (picoseconds) | tu (for TUs,default)\n");
printf("\t\tMore than one <slot-value>' can be specified for setting\n");
printf("\t\tmultiple time slots\n");
/* show examples */
printf("\n\tExample: wl proxd ftm config avail none\n");
printf("\t wl proxd ftm config avail time-ref dev-tsf slot 11:100s:100tu\n");
printf("\t wl proxd ftm 1 config avail time-ref dev-tsf slot 11:200s:300tu");
printf(" 11:600s:400tu\n");
return;
}
/*
* handle
* wl proxd -h
* wl proxd -h ftm
* wl proxd -h ftm <cmd>
* wl proxd -h ftm config options
* Output:
* BCME_USAGE_ERROR -- caller should bring up 'proxd' level help messages
* BCME_OK -- this func displays context-help for FTM method,
* caller does not need to show any help messages.
*/
static int
ftm_handle_help(char **argv)
{
const ftm_subcmd_info_t *p_subcmd_info;
if (!*argv)
return BCME_USAGE_ERROR;
if (stricmp(*argv, "ftm") != 0) /* check 'wl proxd -h ftm' */
return BCME_USAGE_ERROR;
++argv;
if (*argv == NULL) {
/* show help messages for 'wl proxd -h ftm' */
ftm_display_method_help();
return BCME_OK;
}
/* parse 'wl proxd -h ftm <cmd>' */
p_subcmd_info = ftm_get_subcmd_info(*argv);
if (p_subcmd_info != NULL) {
if (p_subcmd_info->cmdid == WL_PROXD_CMD_CONFIG) {
/* help for 'wl proxd -h ftm config' */
++argv;
if (*argv != NULL) { /* parse 'wl proxd -h ftm config options' */
if (stricmp(*argv, "options") == 0) {
/* display help for 'wl proxd -h ftm config options' */
ftm_display_config_options_help();
return BCME_OK;
}
if (stricmp(*argv, "avail") == 0) {
/* display help for 'wl proxd -h ftm config avail' */
ftm_display_config_avail_help();
return BCME_OK;
}
}
/* display help for 'wl proxd -h ftm config' */
ftm_display_config_help();
return BCME_OK;
}
else {
/* print help messages for a specific FTM sub-command */
ftm_display_cmd_help(p_subcmd_info, "");
return BCME_OK;
}
}
/* invalid <cmd>, display help messages for FTM method */
ftm_display_method_help();
return BCME_OK;
}
static const ftm_strmap_entry_t ftm_event_type_loginfo[] = {
/* wl_proxd_event_type_t, text-string */
{ WL_PROXD_EVENT_NONE, "none" },
{ WL_PROXD_EVENT_SESSION_CREATE, "session create" },
{ WL_PROXD_EVENT_SESSION_START, "session start" },
{ WL_PROXD_EVENT_FTM_REQ, "FTM req" },
{ WL_PROXD_EVENT_BURST_START, "burst start" },
{ WL_PROXD_EVENT_BURST_END, "burst end" },
{ WL_PROXD_EVENT_SESSION_END, "session end" },
{ WL_PROXD_EVENT_SESSION_RESTART, "session restart" },
{ WL_PROXD_EVENT_BURST_RESCHED, "burst rescheduled" },
{ WL_PROXD_EVENT_SESSION_DESTROY, "session destroy" },
{ WL_PROXD_EVENT_RANGE_REQ, "range request" },
{ WL_PROXD_EVENT_FTM_FRAME, "FTM frame" },
{ WL_PROXD_EVENT_DELAY, "delay" },
{ WL_PROXD_EVENT_VS_INITIATOR_RPT, "initiator-report " }, /* rx initiator-rpt */
{ WL_PROXD_EVENT_RANGING, "ranging " },
{ WL_PROXD_EVENT_LCI_MEAS_REP, "LCI measurement report" },
{ WL_PROXD_EVENT_CIVIC_MEAS_REP, "civic measurement report" },
{ WL_PROXD_EVENT_START_WAIT, "start wait" },
};
#if defined(linux)
static const ftm_strmap_entry_t*
ftm_get_event_type_loginfo(wl_proxd_event_type_t event_type)
{
/* look up 'event-type' from a predefined table */
return ftm_get_strmap_info((int32) event_type,
ftm_event_type_loginfo, ARRAYSIZE(ftm_event_type_loginfo));
}
/*
* check FTM event
* return -1: if event's version does not match. In this case,
* caller should continue the event checking.
* return 0: this func reports receving a new-version FTM-event and
* caller should skip the checking for this event.
*/
static int
ftm_event_check(bcm_event_t *p_bcm_event)
{
int status;
wl_proxd_event_t *p_event;
uint16 version;
wl_proxd_event_type_t event_type;
const ftm_strmap_entry_t *p_loginfo;
int tlvs_len;
/* move to bcm event payload, which is proxd event structure */
p_event = (wl_proxd_event_t *) (p_bcm_event + 1);
version = ltoh16(p_event->version);
if (version < WL_PROXD_API_VERSION) {
#ifdef WL_FTM_DEBUG
printf("ignore non-ftm event version = 0x%x < WL_PROXD_API_VERSION (0x%x)\n",
version, WL_PROXD_API_VERSION);
#endif /* WL_FTM_DEBUG */
return -1; /* let caller handle the old version */
}
event_type = (wl_proxd_event_type_t) ltoh16(p_event->type);
#ifdef WL_FTM_DEBUG
printf("event_type=0x%x, ntoh16()=0x%x, ltoh16()=0x%x",
p_event->type, ntoh16(p_event->type), ltoh16(p_event->type));
#endif /* WL_FTM_DEBUG */
p_loginfo = ftm_get_event_type_loginfo(event_type);
if (p_loginfo == NULL) {
printf("receive an invalid FTM event %d\n", event_type);
return 0; /* ignore this event */
}
/* get TLVs len, skip over event header */
tlvs_len = ltoh16(p_event->len) - OFFSETOF(wl_proxd_event_t, tlvs);
printf("receive '%s' event: version=0x%x len=%d method=%s sid=%d tlvs_len=%d\n",
p_loginfo->text,
version,
ltoh16(p_event->len),
ftm_method_value_to_logstr(ltoh16(p_event->method)),
ltoh16(p_event->sid),
tlvs_len);
/* print event contents TLVs */
if (tlvs_len > 0) {
/* unpack TLVs and invokes the cbfn to print the event content TLVs */
status = bcm_unpack_xtlv_buf((void *) NULL, (uint8 *)&p_event->tlvs[0],
tlvs_len, BCM_XTLV_OPTION_ALIGN32, ftm_unpack_xtlv_cbfn);
if (status != BCME_OK)
printf("Failed to unpack xtlv for an event\n");
}
return 0; /* indicate we have processed this FTM event */
}
#endif /* linux */
#ifdef WL_FTM_DEBUG
/*
* Format an 'event' bitmask to a text-string to caller-provided buffer
*/
static void
ftm_format_event_mask(wl_proxd_event_type_t event, char *p_strbuf, int bufsize)
{
int i, nChars;
int event_enabled_count = 0;
memset(p_strbuf, 0, bufsize);
char *p_tmpbuf = p_strbuf;
const ftm_strmap_entry_t *p_loginfo = &ftm_event_type_loginfo[0];
for (i = 0; i < (int) ARRAYSIZE(ftm_event_type_loginfo); i++) {
if (WL_PROXD_EVENT_ENABLED(event, (wl_proxd_event_type_t) p_loginfo->id)) {
if (event_enabled_count == 0) {
if ((nChars = snprintf(p_tmpbuf, bufsize, "(")) < 0)
return; /* error, ignore */
bufsize -= nChars;
p_tmpbuf += nChars;
}
nChars = snprintf(p_tmpbuf, bufsize, "'%s' ", p_loginfo->text);
if (nChars < 0)
return; /* abort if error */
bufsize -= nChars;
p_tmpbuf += nChars;
event_enabled_count++;
}
p_loginfo++;
}
if (event_enabled_count > 0)
snprintf(p_tmpbuf, bufsize, ")");
}
#endif /* WL_FTM_DEBUG */
/*
* 'wl proxd ftm tune' handler,
* wl proxd ftm tune
*/
static int
ftm_handle_tune_options(char **argv, wl_proxd_tlv_t **p_tlv, uint16 *p_buf_space_left,
wl_proxd_params_tof_tune_t *tof_tune)
{
miniopt_t to;
int opt_err;
int ret = BCME_USAGE_ERROR;
if (*argv == NULL)
return BCME_USAGE_ERROR;
miniopt_init(&to, "tune", NULL, FALSE);
while ((opt_err = miniopt(&to, argv)) != -1) {
if (opt_err == 1) {
return BCME_USAGE_ERROR;
}
argv += to.consumed;
ret = proxd_tune_set_param_from_opt("proxd ftm tune", &to, tof_tune);
}
#ifdef WL_FTM_DEBUG
prhex("tune_opt", (uint8*)tof_tune, sizeof(wl_proxd_params_tof_tune_t));
#endif /* WL_FTM_DEBUG */
ret = bcm_pack_xtlv_entry((uint8 **)p_tlv, p_buf_space_left,
WL_PROXD_TLV_ID_TUNE, sizeof(wl_proxd_params_tof_tune_t), (uint8*)tof_tune,
BCM_XTLV_OPTION_ALIGN32);
if (ret != BCME_OK) {
printf("%s: failed to pack proxd ftm tune in xtlv, err=%d\n",
__FUNCTION__, ret);
return ret;
}
return BCME_OK;
}
/* Used for getting the current options before setting the new ones only */
static int
ftm_tune_cbfn(void *ctx, const uint8 *p_data, uint16 tlvid, uint16 len)
{
wl_proxd_params_tof_tune_t *tunep = (wl_proxd_params_tof_tune_t *)ctx;
if (tlvid == WL_PROXD_TLV_ID_TUNE) {
#ifdef WL_FTM_DEBUG
prhex("ftm_tune_cbbn", p_data, len);
#endif /* WL_FTM_DEBUG */
if (len < sizeof(wl_proxd_params_tof_tune_t)) {
/* FW has older version */
memcpy(&tunep->Ki, p_data, len);
} else {
memcpy(tunep, p_data, sizeof(wl_proxd_params_tof_tune_t));
}
}
return BCME_OK;
}
static int
ftm_subcmd_tune(void *wl, const ftm_subcmd_info_t *p_subcmd_info,
wl_proxd_method_t method, wl_proxd_session_id_t session_id, char **argv)
{
uint16 proxd_tune_method;
uint16 proxd_iovsize;
wl_proxd_iov_t *p_proxd_iov, *p_iovresp;
uint16 bufsize;
wl_proxd_tlv_t *p_tlv;
uint16 buf_space_left;
uint16 all_tlvsize = 0;
int ret = BCME_OK;
wl_proxd_params_tof_tune_t tof_tune; /* TOF tune parameters */
memset(&tof_tune, 0, sizeof(tof_tune));
/* this should apply to a method command */
if (session_id != WL_PROXD_SESSION_ID_GLOBAL) {
printf("error: no session-id is allowed for tune\n");
return BCME_OK;
}
/* skip the command name and check if mandatory exists */
if (!*argv) {
fprintf(stderr, "missing mandatory parameter \'method\'\n");
return BCME_USAGE_ERROR;
}
/* parse method */
proxd_tune_method = (uint16)atoi(argv[0]);
if (proxd_tune_method == 0) {
fprintf(stderr, "invalid parameter \'method\'\n");
return BCME_USAGE_ERROR;
}
/* only supports PROXD_TOF_METHOD */
if (proxd_tune_method == PROXD_RSSI_METHOD)
return BCME_OK;
if (!*++argv) {
/* get */
return ftm_common_getcmd_handler(wl, p_subcmd_info, method, session_id, argv);
} else {
/* allocate iovar getset buffer */
p_proxd_iov = ftm_alloc_getset_buf(method, session_id,
p_subcmd_info->cmdid, sizeof(wl_proxd_params_tof_tune_t),
&proxd_iovsize);
if (p_proxd_iov == (wl_proxd_iov_t *) NULL)
return BCME_NOMEM;
bufsize = proxd_iovsize - WL_PROXD_IOV_HDR_SIZE;
p_tlv = &p_proxd_iov->tlvs[0];
buf_space_left = bufsize;
/* get current tune params */
ret = wlu_var_getbuf(wl, "proxd", p_proxd_iov, proxd_iovsize,
(void *)&p_iovresp);
if (ret != BCME_OK) {
#ifdef WL_FTM_DEBUG
printf("%s: failed to send getbuf proxd iovar, status=%d\n",
__FUNCTION__, ret);
#endif /* WL_FTM_DEBUG */
goto done;
}
if (p_iovresp != NULL) {
int tlvs_len = ltoh16(p_iovresp->len) - WL_PROXD_IOV_HDR_SIZE;
if (tlvs_len > 0) {
ret = bcm_unpack_xtlv_buf(&tof_tune, (uint8 *)p_iovresp->tlvs,
tlvs_len, BCM_XTLV_OPTION_ALIGN32, ftm_tune_cbfn);
}
}
/* handle options */
ret = ftm_handle_tune_options(argv, &p_tlv, &buf_space_left, &tof_tune);
if (ret == BCME_OK) {
/* prep to transport xtlv */
all_tlvsize = bufsize - buf_space_left;
p_proxd_iov->len = htol16(all_tlvsize + WL_PROXD_IOV_HDR_SIZE);
ret = wlu_var_setbuf(wl, "proxd", p_proxd_iov,
all_tlvsize + WL_PROXD_IOV_HDR_SIZE);
}
}
done:
/* clean up */
free(p_proxd_iov);
#ifdef wL_FTM_DEBUG
if (ret != BCME_OK)
printf("error: exit %s, status = %d\n", __FUNCTION__, ret);
#endif /* WL_FTM_DEBUG */
return ret;
}
static int
proxd_tune_display(wl_proxd_params_tof_tune_t *tof_tune, uint16 len)
{
int err = BCME_OK;
int i, version = 0;
if (!tof_tune)
return err;
printf("Ki=%d \n", dtoh32(tof_tune->Ki));
printf("Kt=%d \n", dtoh32(tof_tune->Kt));
printf("vhtack=%d \n", dtoh16(tof_tune->vhtack));
printf("seq_en=%d\n", dtoh16(tof_tune->seq_en));
printf("core=%d\n", tof_tune->core);
printf("sw_adj=%d\n", dtoh16(tof_tune->sw_adj));
printf("hw_adj=%d\n", dtoh16(tof_tune->hw_adj));
printf("minDT = %d\n", tof_tune->minDT);
printf("maxDT = %d\n", tof_tune->maxDT);
printf("threshold_log2=%d %d %d seqtx %d seqrx %d 2g %d seqtx5g20 %d"
" seqrx5g20 %d seqtx2g20 %d seqrx2g20 %d\n",
dtoh16(tof_tune->N_log2[TOF_BW_20MHZ_INDEX]),
dtoh16(tof_tune->N_log2[TOF_BW_40MHZ_INDEX]),
dtoh16(tof_tune->N_log2[TOF_BW_80MHZ_INDEX]),
dtoh16(tof_tune->N_log2[TOF_BW_SEQTX_INDEX]),
dtoh16(tof_tune->N_log2[TOF_BW_SEQRX_INDEX]),
dtoh16(tof_tune->N_log2_2g),
dtoh16(tof_tune->seq_5g20.N_tx_log2),
dtoh16(tof_tune->seq_5g20.N_rx_log2),
dtoh16(tof_tune->seq_2g20.N_tx_log2),
dtoh16(tof_tune->seq_2g20.N_rx_log2));
printf("threshold_scale=%d %d %d seqtx %d seqrx %d 2g %d seqtx5g20 %d"
" seqrx5g20 %d seqtx2g20 %d seqrx2g20 %d\n",
dtoh16(tof_tune->N_scale[TOF_BW_20MHZ_INDEX]),
dtoh16(tof_tune->N_scale[TOF_BW_40MHZ_INDEX]),
dtoh16(tof_tune->N_scale[TOF_BW_80MHZ_INDEX]),
dtoh16(tof_tune->N_scale[TOF_BW_SEQTX_INDEX]),
dtoh16(tof_tune->N_scale[TOF_BW_SEQRX_INDEX]),
dtoh16(tof_tune->N_scale_2g),
dtoh16(tof_tune->seq_5g20.N_tx_scale),
dtoh16(tof_tune->seq_5g20.N_rx_scale),
dtoh16(tof_tune->seq_2g20.N_tx_scale),
dtoh16(tof_tune->seq_2g20.N_rx_scale));
printf("total_frmcnt=%d \n", tof_tune->totalfrmcnt);
printf("reserve_media=%d \n", tof_tune->rsv_media);
printf("flags=0x%x \n", dtoh16(tof_tune->flags));
for (i = 0; i < TOF_BW_NUM; i++) {
printf("window length %dMHz = %d\n",
(20 << i), tof_tune->w_len[i]);
printf("window offset %dMHz = %d\n",
(20 << i), tof_tune->w_offset[i]);
}
printf("seq window length 5G-20MHz = %2d 2G-20MHz = %2d\n",
tof_tune->seq_5g20.w_len,
tof_tune->seq_2g20.w_len);
printf("seq window offset 5G-20MHz = %2d 2G-20MHz = %2d\n",
tof_tune->seq_5g20.w_offset,
tof_tune->seq_2g20.w_offset);
printf("frame count=%d %d %d seq %d\n",
tof_tune->ftm_cnt[TOF_BW_20MHZ_INDEX],
tof_tune->ftm_cnt[TOF_BW_40MHZ_INDEX],
tof_tune->ftm_cnt[TOF_BW_80MHZ_INDEX],
tof_tune->ftm_cnt[TOF_BW_SEQTX_INDEX]);
if (len == sizeof(wl_proxd_params_tof_tune_t)) {
version = dtoh32(tof_tune->version);
switch (version) {
case WL_PROXD_TUNE_VERSION_1:
printf("bitflip threshold=%u\n", dtoh16(tof_tune->bitflip_thresh));
printf("SNR threshold=%u\n", dtoh16(tof_tune->snr_thresh));
printf("2G receive sensitivity threshold=%d\n", tof_tune->recv_2g_thresh);
printf("ACS GDV threshold=%u\n", dtoh32(tof_tune->acs_gdv_thresh));
printf("ACS RSSI threshold=%d\n", tof_tune->acs_rssi_thresh);
printf("Smoothing window enable=%u\n", tof_tune->smooth_win_en);
break;
default:
break;
}
}
return err;
}