NED
/
tegrakernel
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
tegrakernel/kernel/nvidia/drivers/net/wireless/bcmdhd_pcie/dhd_rtt.c

732 lines
21 KiB
C
Raw Blame History

/*
* Broadcom Dongle Host Driver (DHD), RTT
*
* Portions of this code are copyright (c) 2017 Cypress Semiconductor Corporation
*
* Copyright (C) 1999-2017, Broadcom Corporation
*
* Unless you and Broadcom execute a separate written software license
* agreement governing use of this software, this software is licensed to you
* under the terms of the GNU General Public License version 2 (the "GPL"),
* available at http://www.broadcom.com/licenses/GPLv2.php, with the
* following added to such license:
*
* As a special exception, the copyright holders of this software give you
* permission to link this software with independent modules, and to copy and
* distribute the resulting executable under terms of your choice, provided that
* you also meet, for each linked independent module, the terms and conditions of
* the license of that module. An independent module is a module which is not
* derived from this software. The special exception does not apply to any
* modifications of the software.
*
* Notwithstanding the above, under no circumstances may you combine this
* software in any way with any other Broadcom software provided under a license
* other than the GPL, without Broadcom's express prior written consent.
*
* $Id: dhd_rtt.c 612549 2016-01-14 07:39:32Z $
*/
#ifdef RTT_SUPPORT
#include <typedefs.h>
#include <osl.h>
#include <epivers.h>
#include <bcmutils.h>
#include <bcmendian.h>
#include <linuxver.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/sort.h>
#include <dngl_stats.h>
#include <wlioctl.h>
#include <proto/bcmevent.h>
#include <dhd.h>
#include <dhd_rtt.h>
#include <dhd_dbg.h>
#define GET_RTTSTATE(dhd) ((rtt_status_info_t *)dhd->rtt_state)
static DEFINE_SPINLOCK(noti_list_lock);
#define NULL_CHECK(p, s, err) \
do { \
if (!(p)) { \
printf("NULL POINTER (%s) : %s\n", __FUNCTION__, (s)); \
err = BCME_ERROR; \
return err; \
} \
} while (0)
#define RTT_TWO_SIDED(capability) \
do { \
if ((capability & RTT_CAP_ONE_WAY) == (uint8) (RTT_CAP_ONE_WAY)) \
return FALSE; \
else \
return TRUE; \
} while (0)
#define TIMESPEC_TO_US(ts) (((uint64)(ts).tv_sec * USEC_PER_SEC) + \
(ts).tv_nsec / NSEC_PER_USEC)
struct rtt_noti_callback {
struct list_head list;
void *ctx;
dhd_rtt_compl_noti_fn noti_fn;
};
typedef struct rtt_status_info {
dhd_pub_t *dhd;
int8 status; /* current status for the current entry */
int8 cur_idx; /* current entry to do RTT */
int32 capability; /* rtt capability */
struct mutex rtt_mutex;
rtt_config_params_t rtt_config;
struct work_struct work;
struct list_head noti_fn_list;
struct list_head rtt_results_cache; /* store results for RTT */
} rtt_status_info_t;
static int dhd_rtt_start(dhd_pub_t *dhd);
chanspec_t
dhd_rtt_convert_to_chspec(wifi_channel_info_t channel)
{
int bw;
/* set witdh to 20MHZ for 2.4G HZ */
if (channel.center_freq >= 2400 && channel.center_freq <= 2500) {
channel.width = WIFI_CHAN_WIDTH_20;
}
switch (channel.width) {
case WIFI_CHAN_WIDTH_20:
bw = WL_CHANSPEC_BW_20;
break;
case WIFI_CHAN_WIDTH_40:
bw = WL_CHANSPEC_BW_40;
break;
case WIFI_CHAN_WIDTH_80:
bw = WL_CHANSPEC_BW_80;
break;
case WIFI_CHAN_WIDTH_160:
bw = WL_CHANSPEC_BW_160;
break;
default:
DHD_ERROR(("doesn't support this bandwith : %d", channel.width));
bw = -1;
break;
}
return wf_channel2chspec(wf_mhz2channel(channel.center_freq, 0), bw);
}
int
dhd_rtt_set_cfg(dhd_pub_t *dhd, rtt_config_params_t *params)
{
int err = BCME_OK;
int idx;
rtt_status_info_t *rtt_status;
NULL_CHECK(params, "params is NULL", err);
NULL_CHECK(dhd, "dhd is NULL", err);
rtt_status = GET_RTTSTATE(dhd);
NULL_CHECK(rtt_status, "rtt_status is NULL", err);
if (rtt_status->capability == RTT_CAP_NONE) {
DHD_ERROR(("doesn't support RTT \n"));
return BCME_ERROR;
}
if (rtt_status->status == RTT_STARTED) {
DHD_ERROR(("rtt is already started\n"));
return BCME_BUSY;
}
DHD_RTT(("%s enter\n", __FUNCTION__));
bcopy(params, &rtt_status->rtt_config, sizeof(rtt_config_params_t));
rtt_status->status = RTT_STARTED;
/* start to measure RTT from 1th device */
/* find next target to trigger RTT */
for (idx = rtt_status->cur_idx; idx < rtt_status->rtt_config.rtt_target_cnt; idx++) {
/* skip the disabled device */
if (rtt_status->rtt_config.target_info[idx].disable) {
continue;
} else {
/* set the idx to cur_idx */
rtt_status->cur_idx = idx;
break;
}
}
if (idx < rtt_status->rtt_config.rtt_target_cnt) {
DHD_RTT(("rtt_status->cur_idx : %d\n", rtt_status->cur_idx));
schedule_work(&rtt_status->work);
}
return err;
}
int
dhd_rtt_stop(dhd_pub_t *dhd, struct ether_addr *mac_list, int mac_cnt)
{
int err = BCME_OK;
int i = 0, j = 0;
rtt_status_info_t *rtt_status;
NULL_CHECK(dhd, "dhd is NULL", err);
rtt_status = GET_RTTSTATE(dhd);
NULL_CHECK(rtt_status, "rtt_status is NULL", err);
if (rtt_status->status == RTT_STOPPED) {
DHD_ERROR(("rtt is not started\n"));
return BCME_OK;
}
DHD_RTT(("%s enter\n", __FUNCTION__));
mutex_lock(&rtt_status->rtt_mutex);
for (i = 0; i < mac_cnt; i++) {
for (j = 0; j < rtt_status->rtt_config.rtt_target_cnt; j++) {
if (!bcmp(&mac_list[i], &rtt_status->rtt_config.target_info[j].addr,
ETHER_ADDR_LEN)) {
rtt_status->rtt_config.target_info[j].disable = TRUE;
}
}
}
mutex_unlock(&rtt_status->rtt_mutex);
return err;
}
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, 0, 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;
}
if (err == BCME_BUSY) {
DHD_RTT(("BCME_BUSY occurred\n"));
}
/* 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 */
/* initiator will send the rtt result to the target */
proxd_tune.u.tof_tune.flags = htol32(WL_PROXD_FLAG_INITIATOR_REPORT);
tof_params->timeout = 10; /* 10ms for timeout */
rspec = WL_RSPEC_ENCODE_VHT; /* 11ac VHT */
nss = 1; /* default Nss = 1 */
mcs = 0; /* default MCS 0 */
rspec |= (nss << WL_RSPEC_VHT_NSS_SHIFT) | mcs;
bw = 0;
switch (CHSPEC_BW(rtt_target->chanspec)) {
case WL_CHANSPEC_BW_20:
bw = WL_RSPEC_BW_20MHZ;
break;
case WL_CHANSPEC_BW_40:
bw = WL_RSPEC_BW_40MHZ;
break;
case WL_CHANSPEC_BW_80:
bw = WL_RSPEC_BW_80MHZ;
break;
case WL_CHANSPEC_BW_160:
bw = WL_RSPEC_BW_160MHZ;
break;
default:
DHD_ERROR(("CHSPEC_BW not supported : %d",
CHSPEC_BW(rtt_target->chanspec)));
goto exit;
}
rspec |= bw;
tof_params->tx_rate = htol16(rspec & 0xffff);
tof_params->vht_rate = htol16(rspec >> 16);
}
/* Set Method to TOF */
proxd_tune.method = PROXD_TOF_METHOD;
err = dhd_iovar(dhd, 0, "proxd_tune", (char *)&proxd_tune, sizeof(proxd_tune), 1);
if (err < 0) {
DHD_ERROR(("%s : failed to set proxd_tune %d\n", __FUNCTION__, err));
goto exit;
}
/* Set Method to TOF */
proxd_params.method = PROXD_TOF_METHOD;
err = dhd_iovar(dhd, 0, "proxd_params", (char *)&proxd_params, sizeof(proxd_params), 1);
if (err < 0) {
DHD_ERROR(("%s : failed to set proxd_params %d\n", __FUNCTION__, err));
goto exit;
}
err = dhd_iovar(dhd, 0, "proxd_find", (char *)NULL, 0, 1);
if (err < 0) {
DHD_ERROR(("%s : failed to set proxd_find %d\n", __FUNCTION__, err));
goto exit;
}
exit:
if (err < 0) {
rtt_status->status = RTT_STOPPED;
if (set_mpc) {
/* enable mpc again in case of error */
mpc = 1;
err = dhd_iovar(dhd, 0, "mpc", (char *)&mpc, sizeof(mpc), 1);
}
}
return err;
}
int
dhd_rtt_register_noti_callback(dhd_pub_t *dhd, void *ctx, dhd_rtt_compl_noti_fn noti_fn)
{
int err = BCME_OK;
struct rtt_noti_callback *cb = NULL, *iter;
rtt_status_info_t *rtt_status;
NULL_CHECK(dhd, "dhd is NULL", err);
NULL_CHECK(noti_fn, "noti_fn is NULL", err);
rtt_status = GET_RTTSTATE(dhd);
NULL_CHECK(rtt_status, "rtt_status is NULL", err);
spin_lock_bh(&noti_list_lock);
list_for_each_entry(iter, &rtt_status->noti_fn_list, list) {
if (iter->noti_fn == noti_fn) {
goto exit;
}
}
cb = kmalloc(sizeof(struct rtt_noti_callback), GFP_ATOMIC);
if (!cb) {
err = -ENOMEM;
goto exit;
}
cb->noti_fn = noti_fn;
cb->ctx = ctx;
list_add(&cb->list, &rtt_status->noti_fn_list);
exit:
spin_unlock_bh(&noti_list_lock);
return err;
}
int
dhd_rtt_unregister_noti_callback(dhd_pub_t *dhd, dhd_rtt_compl_noti_fn noti_fn)
{
int err = BCME_OK;
struct rtt_noti_callback *cb = NULL, *iter;
rtt_status_info_t *rtt_status;
NULL_CHECK(dhd, "dhd is NULL", err);
NULL_CHECK(noti_fn, "noti_fn is NULL", err);
rtt_status = GET_RTTSTATE(dhd);
NULL_CHECK(rtt_status, "rtt_status is NULL", err);
spin_lock_bh(&noti_list_lock);
list_for_each_entry(iter, &rtt_status->noti_fn_list, list) {
if (iter->noti_fn == noti_fn) {
cb = iter;
list_del(&cb->list);
break;
}
}
spin_unlock_bh(&noti_list_lock);
if (cb) {
kfree(cb);
}
return err;
}
static int
dhd_rtt_convert_to_host(rtt_result_t *rtt_results, const wl_proxd_event_data_t* evp)
{
int err = BCME_OK;
int i;
char eabuf[ETHER_ADDR_STR_LEN];
char diststr[40];
struct timespec ts;
NULL_CHECK(rtt_results, "rtt_results is NULL", err);
NULL_CHECK(evp, "evp is NULL", err);
DHD_RTT(("%s enter\n", __FUNCTION__));
rtt_results->distance = ntoh32(evp->distance);
rtt_results->sdrtt = ntoh32(evp->sdrtt);
rtt_results->ftm_cnt = ntoh16(evp->ftm_cnt);
rtt_results->avg_rssi = ntoh16(evp->avg_rssi);
rtt_results->validfrmcnt = ntoh16(evp->validfrmcnt);
rtt_results->meanrtt = ntoh32(evp->meanrtt);
rtt_results->modertt = ntoh32(evp->modertt);
rtt_results->medianrtt = ntoh32(evp->medianrtt);
rtt_results->err_code = evp->err_code;
rtt_results->tx_rate.preamble = (evp->OFDM_frame_type == TOF_FRAME_RATE_VHT)? 3 : 0;
rtt_results->tx_rate.nss = 0; /* 1 x 1 */
rtt_results->tx_rate.bw =
(evp->bandwidth == TOF_BW_80MHZ)? 2 : (evp->bandwidth == TOF_BW_40MHZ)? 1 : 0;
rtt_results->TOF_type = evp->TOF_type;
if (evp->TOF_type == TOF_TYPE_ONE_WAY) {
/* convert to 100kbps unit */
rtt_results->tx_rate.bitrate = WL_RATE_6M * 5;
rtt_results->tx_rate.rateMcsIdx = WL_RATE_6M;
} else {
rtt_results->tx_rate.bitrate = WL_RATE_6M * 5;
rtt_results->tx_rate.rateMcsIdx = 0; /* MCS 0 */
}
memset(diststr, 0, sizeof(diststr));
if (rtt_results->distance == 0xffffffff || rtt_results->distance == 0) {
sprintf(diststr, "distance=-1m\n");
} else {
sprintf(diststr, "distance=%d.%d m\n",
rtt_results->distance >> 4, ((rtt_results->distance & 0xf) * 125) >> 1);
}
if (ntoh32(evp->mode) == WL_PROXD_MODE_INITIATOR) {
DHD_RTT(("Target:(%s) %s;\n", bcm_ether_ntoa((&evp->peer_mac), eabuf), diststr));
DHD_RTT(("RTT : mean %d mode %d median %d\n", rtt_results->meanrtt,
rtt_results->modertt, rtt_results->medianrtt));
} else {
DHD_RTT(("Initiator:(%s) %s; ", bcm_ether_ntoa((&evp->peer_mac), eabuf), diststr));
}
if (rtt_results->sdrtt > 0) {
DHD_RTT(("sigma:%d.%d\n", rtt_results->sdrtt/10, rtt_results->sdrtt % 10));
} else {
DHD_RTT(("sigma:0\n"));
}
DHD_RTT(("rssi:%d validfrmcnt %d, err_code : %d\n", rtt_results->avg_rssi,
rtt_results->validfrmcnt, evp->err_code));
switch (evp->err_code) {
case TOF_REASON_OK:
rtt_results->err_code = RTT_REASON_SUCCESS;
break;
case TOF_REASON_TIMEOUT:
rtt_results->err_code = RTT_REASON_TIMEOUT;
break;
case TOF_REASON_NOACK:
rtt_results->err_code = RTT_REASON_NO_RSP;
break;
case TOF_REASON_ABORT:
rtt_results->err_code = RTT_REASON_ABORT;
break;
default:
rtt_results->err_code = RTT_REASON_FAILURE;
break;
}
rtt_results->peer_mac = evp->peer_mac;
/* get the time elapsed from boot time */
get_monotonic_boottime(&ts);
rtt_results->ts = (uint64) TIMESPEC_TO_US(ts);
for (i = 0; i < rtt_results->ftm_cnt; i++) {
rtt_results->ftm_buff[i].value = ltoh32(evp->ftm_buff[i].value);
rtt_results->ftm_buff[i].rssi = ltoh32(evp->ftm_buff[i].rssi);
}
return err;
}
int
dhd_rtt_event_handler(dhd_pub_t *dhd, wl_event_msg_t *event, void *event_data)
{
int err = BCME_OK;
int len = 0;
int idx;
uint event_type, reason, ftm_cnt;
rtt_status_info_t *rtt_status;
wl_proxd_event_data_t* evp;
struct rtt_noti_callback *iter;
rtt_result_t *rtt_result, *entry, *next;
gfp_t kflags;
NULL_CHECK(dhd, "dhd is NULL", err);
rtt_status = GET_RTTSTATE(dhd);
NULL_CHECK(rtt_status, "rtt_status is NULL", err);
event_type = ntoh32_ua((void *)&event->event_type);
reason = ntoh32_ua((void *)&event->reason);
if (event_type != WLC_E_PROXD) {
goto exit;
}
kflags = in_softirq()? GFP_ATOMIC : GFP_KERNEL;
evp = (wl_proxd_event_data_t*)event_data;
DHD_RTT(("%s enter : mode: %s, reason :%d \n", __FUNCTION__,
(ntoh16(evp->mode) == WL_PROXD_MODE_INITIATOR)?
"initiator":"target", reason));
switch (reason) {
case WLC_E_PROXD_STOP:
DHD_RTT(("WLC_E_PROXD_STOP\n"));
break;
case WLC_E_PROXD_ERROR:
case WLC_E_PROXD_COMPLETED:
if (reason == WLC_E_PROXD_ERROR) {
DHD_RTT(("WLC_E_PROXD_ERROR\n"));
} else {
DHD_RTT(("WLC_E_PROXD_COMPLETED\n"));
}
if (!in_atomic()) {
mutex_lock(&rtt_status->rtt_mutex);
}
ftm_cnt = ntoh16(evp->ftm_cnt);
if (ftm_cnt > 0) {
len = OFFSETOF(rtt_result_t, ftm_buff);
} else {
len = sizeof(rtt_result_t);
}
/* check whether the results is already reported or not */
list_for_each_entry(entry, &rtt_status->rtt_results_cache, list) {
if (!memcmp(&entry->peer_mac, &evp->peer_mac, ETHER_ADDR_LEN)) {
if (!in_atomic()) {
mutex_unlock(&rtt_status->rtt_mutex);
}
goto exit;
}
}
rtt_result = kzalloc(len + sizeof(ftm_sample_t) * ftm_cnt, kflags);
if (!rtt_result) {
if (!in_atomic()) {
mutex_unlock(&rtt_status->rtt_mutex);
}
err = -ENOMEM;
goto exit;
}
/* point to target_info in status struct and increase pointer */
rtt_result->target_info = &rtt_status->rtt_config.target_info[rtt_status->cur_idx];
/* find next target to trigger RTT */
for (idx = (rtt_status->cur_idx + 1);
idx < rtt_status->rtt_config.rtt_target_cnt; idx++) {
/* skip the disabled device */
if (rtt_status->rtt_config.target_info[idx].disable) {
continue;
} else {
/* set the idx to cur_idx */
rtt_status->cur_idx = idx;
break;
}
}
/* convert the event results to host format */
dhd_rtt_convert_to_host(rtt_result, evp);
list_add_tail(&rtt_result->list, &rtt_status->rtt_results_cache);
if (idx < rtt_status->rtt_config.rtt_target_cnt) {
/* restart to measure RTT from next device */
schedule_work(&rtt_status->work);
} else {
DHD_RTT(("RTT_STOPPED\n"));
rtt_status->status = RTT_STOPPED;
/* to turn on mpc mode */
schedule_work(&rtt_status->work);
/* notify the completed information to others */
list_for_each_entry(iter, &rtt_status->noti_fn_list, list) {
iter->noti_fn(iter->ctx, &rtt_status->rtt_results_cache);
}
/* remove the rtt results in cache */
list_for_each_entry_safe(rtt_result, next,
&rtt_status->rtt_results_cache, list) {
list_del(&rtt_result->list);
kfree(rtt_result);
}
/* reinit the HEAD */
INIT_LIST_HEAD(&rtt_status->rtt_results_cache);
/* clear information for rtt_config */
bzero(&rtt_status->rtt_config, sizeof(rtt_status->rtt_config));
rtt_status->cur_idx = 0;
}
if (!in_atomic()) {
mutex_unlock(&rtt_status->rtt_mutex);
}
break;
case WLC_E_PROXD_GONE:
DHD_RTT(("WLC_E_PROXD_GONE\n"));
break;
case WLC_E_PROXD_START:
/* event for targets / accesspoints */
DHD_RTT(("WLC_E_PROXD_START\n"));
break;
case WLC_E_PROXD_COLLECT_START:
DHD_RTT(("WLC_E_PROXD_COLLECT_START\n"));
break;
case WLC_E_PROXD_COLLECT_STOP:
DHD_RTT(("WLC_E_PROXD_COLLECT_STOP\n"));
break;
case WLC_E_PROXD_COLLECT_COMPLETED:
DHD_RTT(("WLC_E_PROXD_COLLECT_COMPLETED\n"));
break;
case WLC_E_PROXD_COLLECT_ERROR:
DHD_RTT(("WLC_E_PROXD_COLLECT_ERROR; "));
break;
default:
DHD_ERROR(("WLC_E_PROXD: supported EVENT reason code:%d\n", reason));
break;
}
exit:
return err;
}
static void
dhd_rtt_work(struct work_struct *work)
{
rtt_status_info_t *rtt_status;
dhd_pub_t *dhd;
rtt_status = container_of(work, rtt_status_info_t, work);
if (rtt_status == NULL) {
DHD_ERROR(("%s : rtt_status is NULL\n", __FUNCTION__));
return;
}
dhd = rtt_status->dhd;
if (dhd == NULL) {
DHD_ERROR(("%s : dhd is NULL\n", __FUNCTION__));
return;
}
(void) dhd_rtt_start(dhd);
}
int
dhd_rtt_capability(dhd_pub_t *dhd, rtt_capabilities_t *capa)
{
rtt_status_info_t *rtt_status;
int err = BCME_OK;
NULL_CHECK(dhd, "dhd is NULL", err);
rtt_status = GET_RTTSTATE(dhd);
NULL_CHECK(rtt_status, "rtt_status is NULL", err);
NULL_CHECK(capa, "capa is NULL", err);
bzero(capa, sizeof(rtt_capabilities_t));
if (rtt_status->capability & RTT_CAP_ONE_WAY) {
capa->rtt_one_sided_supported = 1;
}
if (rtt_status->capability & RTT_CAP_11V_WAY) {
capa->rtt_11v_supported = 1;
}
if (rtt_status->capability & RTT_CAP_11MC_WAY) {
capa->rtt_ftm_supported = 1;
}
if (rtt_status->capability & RTT_CAP_VS_WAY) {
capa->rtt_vs_supported = 1;
}
return err;
}
int
dhd_rtt_init(dhd_pub_t *dhd)
{
int err = BCME_OK;
rtt_status_info_t *rtt_status;
NULL_CHECK(dhd, "dhd is NULL", err);
if (dhd->rtt_state) {
goto exit;
}
dhd->rtt_state = MALLOC(dhd->osh, sizeof(rtt_status_info_t));
if (dhd->rtt_state == NULL) {
DHD_ERROR(("failed to create rtt_state\n"));
goto exit;
}
bzero(dhd->rtt_state, sizeof(rtt_status_info_t));
rtt_status = GET_RTTSTATE(dhd);
rtt_status->dhd = dhd;
err = dhd_iovar(dhd, 0, "proxd_params", NULL, 0, 1);
if (err != BCME_UNSUPPORTED) {
rtt_status->capability |= RTT_CAP_ONE_WAY;
rtt_status->capability |= RTT_CAP_VS_WAY;
DHD_ERROR(("%s: Support RTT Service\n", __FUNCTION__));
}
mutex_init(&rtt_status->rtt_mutex);
INIT_LIST_HEAD(&rtt_status->noti_fn_list);
INIT_LIST_HEAD(&rtt_status->rtt_results_cache);
INIT_WORK(&rtt_status->work, dhd_rtt_work);
exit:
return err;
}
int
dhd_rtt_deinit(dhd_pub_t *dhd)
{
int err = BCME_OK;
rtt_status_info_t *rtt_status;
rtt_result_t *rtt_result, *next;
struct rtt_noti_callback *iter, *iter2;
NULL_CHECK(dhd, "dhd is NULL", err);
rtt_status = GET_RTTSTATE(dhd);
NULL_CHECK(rtt_status, "rtt_status is NULL", err);
rtt_status->status = RTT_STOPPED;
/* clear evt callback list */
if (!list_empty(&rtt_status->noti_fn_list)) {
list_for_each_entry_safe(iter, iter2, &rtt_status->noti_fn_list, list) {
list_del(&iter->list);
kfree(iter);
}
}
/* remove the rtt results */
if (!list_empty(&rtt_status->rtt_results_cache)) {
list_for_each_entry_safe(rtt_result, next, &rtt_status->rtt_results_cache, list) {
list_del(&rtt_result->list);
kfree(rtt_result);
}
}
MFREE(dhd->osh, dhd->rtt_state, sizeof(rtt_status_info_t));
dhd->rtt_state = NULL;
return err;
}
#endif /* RTT_SUPPORT */
Reference in New Issue View Git Blame Copy Permalink