/* wrapper function for wf_chspec_ntoa. In case of an error it puts
* the original chanspec in the output buffer, prepended with "invalid".
* Can be directly used in print routines as it takes care of null
*/
char *
wf_chspec_ntoa_ex(chanspec_t chspec, char *buf)
{
if (wf_chspec_ntoa(chspec, buf) == NULL)
snprintf(buf, CHANSPEC_STR_LEN, "invalid 0x%04x", chspec);
return buf;
}
static void
acs_dump_cscore_body(ch_candidate_t * candi)
{
char buf[CHANSPEC_STR_LEN];
printf("%7s (0x%04x) %3d %3s %s", wf_chspec_ntoa(candi->chspec, buf), candi->chspec,
candi->in_use,
(candi->is_dfs) ? "dfs" : " - ",
(candi->valid) ? "" : " Invalid:");
if (candi->valid) {
acs_dump_ch_score_body(candi->chscore, FALSE);
} else {
acs_dump_reason(candi);
}
}
int wl_cfgnan_set_vars_cbfn(void *ctx, void **tlv_buf,
uint16 type, uint16 len)
{
wl_nan_tlv_data_t *ndata = ((wl_nan_tlv_data_t *)(ctx));
bcm_xtlv_t *ptlv;
struct ether_addr mac;
int ret = BCME_OK;
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
uint8 uv8;
char buf[64];
WL_DBG((" enter, xtlv_type: 0x%x \n", type));
switch (type) {
case WL_NAN_XTLV_ENABLE:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_ENABLE,
sizeof(uv8), &ndata->enabled);
break;
case WL_NAN_XTLV_MASTER_PREF:
/*
* master role and preference mac has them as two u8's,
*
* masterpref: val & 0x0ff
* rnd_factor: val >> 8
*/
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_MASTER_PREF,
sizeof(uint16), &ndata->master_pref);
break;
case WL_NAN_XTLV_IF_ADDR:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_IF_ADDR,
ETHER_ADDR_LEN, &mac);
memcpy(&ndata->mac_addr, &mac, ETHER_ADDR_LEN);
break;
case WL_NAN_XTLV_CLUSTER_ID:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_CLUSTER_ID,
ETHER_ADDR_LEN, &mac);
memcpy(&ndata->clus_id, &mac, ETHER_ADDR_LEN);
break;
case WL_NAN_XTLV_ROLE:
/* nan device role, master, master-sync nosync etc */
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_ROLE, 4,
&ndata->dev_role);
break;
case WL_NAN_XTLV_MAC_CHANSPEC:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_MAC_CHANSPEC,
sizeof(chanspec_t), &ndata->chanspec);
if (wf_chspec_valid(ndata->chanspec)) {
wf_chspec_ntoa(ndata->chanspec, buf);
WL_DBG((" chanspec: %s 0x%x \n", buf, ndata->chanspec));
} else {
WL_DBG((" chanspec: 0x%x is not valid \n", ndata->chanspec));
}
break;
case WL_NAN_XTLV_MAC_AMR:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_MAC_AMR,
NAN_MASTER_RANK_LEN, buf);
memcpy(ndata->amr, buf, NAN_MASTER_RANK_LEN);
break;
case WL_NAN_XTLV_MAC_AMBTT:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_MAC_AMBTT,
sizeof(uint32), &ndata->ambtt);
break;
case WL_NAN_XTLV_MAC_HOPCNT:
ret = bcm_unpack_xtlv_entry(tlv_buf,
WL_NAN_XTLV_MAC_HOPCNT, sizeof(uint8), &ndata->hop_count);
break;
case WL_NAN_XTLV_INSTANCE_ID:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_INSTANCE_ID,
sizeof(wl_nan_instance_id_t), &ndata->inst_id);
break;
case WL_NAN_XTLV_SVC_NAME:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_SVC_NAME,
WL_NAN_SVC_HASH_LEN, ndata->svc_name);
break;
case WL_NAN_XTLV_SVC_PARAMS:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_SVC_PARAMS,
sizeof(wl_nan_disc_params_t), &ndata->params);
break;
case WL_NAN_XTLV_MAC_STATUS:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_MAC_STATUS,
sizeof(wl_nan_status_t), &ndata->nstatus);
break;
case WL_NAN_XTLV_PUBLR_ID:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_PUBLR_ID,
sizeof(uint8), &ndata->pub_id);
break;
case WL_NAN_XTLV_SUBSCR_ID:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_SUBSCR_ID,
sizeof(uint8), &ndata->sub_id);
break;
case WL_NAN_XTLV_MAC_ADDR:
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_MAC_ADDR,
ETHER_ADDR_LEN, &mac);
memcpy(&ndata->mac_addr, &mac, ETHER_ADDR_LEN);
break;
case WL_NAN_XTLV_VNDR:
ptlv = *tlv_buf;
ndata->vend_info.dlen = BCM_XTLV_LEN(ptlv);
ndata->vend_info.data = kzalloc(ndata->vend_info.dlen, kflags);
if (!ndata->vend_info.data) {
WL_ERR((" memory allocation failed \n"));
ret = -ENOMEM;
goto fail;
}
if (ndata->vend_info.data && ndata->vend_info.dlen) {
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_VNDR,
ndata->vend_info.dlen, ndata->vend_info.data);
}
break;
case WL_NAN_XTLV_SVC_INFO:
ptlv = *tlv_buf;
ndata->svc_info.dlen = BCM_XTLV_LEN(ptlv);
ndata->svc_info.data = kzalloc(ndata->svc_info.dlen, kflags);
if (!ndata->svc_info.data) {
WL_ERR((" memory allocation failed \n"));
ret = -ENOMEM;
goto fail;
}
if (ndata->svc_info.data && ndata->svc_info.dlen) {
ret = bcm_unpack_xtlv_entry(tlv_buf, WL_NAN_XTLV_SVC_INFO,
ndata->svc_info.dlen, ndata->svc_info.data);
}
break;
case WL_NAN_XTLV_ZERO:
/* don't parse empty space in the buffer */
ret = BCME_ERROR;
break;
default:
/* skip current tlv, if we don't have a handler */
ret = bcm_skip_xtlv(tlv_buf);
break;
}
fail:
return ret;
}
static int
dhd_rtt_start(dhd_pub_t *dhd) {
int err = BCME_OK;
int mpc = 0;
int nss, mcs, bw;
uint32 rspec = 0;
int8 eabuf[ETHER_ADDR_STR_LEN];
int8 chanbuf[CHANSPEC_STR_LEN];
bool set_mpc = FALSE;
wl_proxd_iovar_t proxd_iovar;
wl_proxd_params_iovar_t proxd_params;
wl_proxd_params_iovar_t proxd_tune;
wl_proxd_params_tof_method_t *tof_params = &proxd_params.u.tof_params;
rtt_status_info_t *rtt_status;
rtt_target_info_t *rtt_target;
NULL_CHECK(dhd, "dhd is NULL", err);
rtt_status = GET_RTTSTATE(dhd);
NULL_CHECK(rtt_status, "rtt_status is NULL", err);
/* turn off mpc in case of non-associted */
if (!dhd_is_associated(dhd, NULL, NULL)) {
err = dhd_iovar(dhd, 0, "mpc", (char *)&mpc, sizeof(mpc), 1);
if (err < 0) {
DHD_ERROR(("%s : failed to set proxd_tune\n", __FUNCTION__));
goto exit;
}
set_mpc = TRUE;
}
if (rtt_status->cur_idx >= rtt_status->rtt_config.rtt_target_cnt) {
err = BCME_RANGE;
goto exit;
}
DHD_RTT(("%s enter\n", __FUNCTION__));
bzero(&proxd_tune, sizeof(proxd_tune));
bzero(&proxd_params, sizeof(proxd_params));
mutex_lock(&rtt_status->rtt_mutex);
/* Get a target information */
rtt_target = &rtt_status->rtt_config.target_info[rtt_status->cur_idx];
mutex_unlock(&rtt_status->rtt_mutex);
/* set role */
proxd_iovar.method = PROXD_TOF_METHOD;
proxd_iovar.mode = WL_PROXD_MODE_INITIATOR;
/* make sure that proxd is stop */
//dhd_iovar(dhd, 0, "proxd_stop", (char *)NULL, 0, 1);
err = dhd_iovar(dhd, 0, "proxd", (char *)&proxd_iovar, sizeof(proxd_iovar), 1);
if (err < 0 && err != BCME_BUSY) {
DHD_ERROR(("%s : failed to set proxd %d\n", __FUNCTION__, err));
goto exit;
}
/* mac address */
bcopy(&rtt_target->addr, &tof_params->tgt_mac, ETHER_ADDR_LEN);
/* frame count */
if (rtt_target->ftm_cnt > RTT_MAX_FRAME_CNT)
rtt_target->ftm_cnt = RTT_MAX_FRAME_CNT;
if (rtt_target->ftm_cnt)
tof_params->ftm_cnt = htol16(rtt_target->ftm_cnt);
else
tof_params->ftm_cnt = htol16(DEFAULT_FTM_CNT);
if (rtt_target->retry_cnt > RTT_MAX_RETRY_CNT)
rtt_target->retry_cnt = RTT_MAX_RETRY_CNT;
/* retry count */
if (rtt_target->retry_cnt)
tof_params->retry_cnt = htol16(rtt_target->retry_cnt);
else
tof_params->retry_cnt = htol16(DEFAULT_RETRY_CNT);
/* chanspec */
tof_params->chanspec = htol16(rtt_target->chanspec);
/* set parameter */
DHD_RTT(("Target addr(Idx %d) %s, Channel : %s for RTT (ftm_cnt %d, rety_cnt : %d)\n",
rtt_status->cur_idx,
bcm_ether_ntoa((const struct ether_addr *)&rtt_target->addr, eabuf),
wf_chspec_ntoa(rtt_target->chanspec, chanbuf), rtt_target->ftm_cnt,
rtt_target->retry_cnt));
if (rtt_target->type == RTT_ONE_WAY) {
proxd_tune.u.tof_tune.flags = htol32(WL_PROXD_FLAG_ONEWAY);
/* report RTT results for initiator */
proxd_tune.u.tof_tune.flags |= htol32(WL_PROXD_FLAG_INITIATOR_RPTRTT);
proxd_tune.u.tof_tune.vhtack = 0;
tof_params->tx_rate = htol16(WL_RATE_6M);
tof_params->vht_rate = htol16((WL_RATE_6M >> 16));
} else { /* RTT TWO WAY */
