/* SPDX-License-Identifier: GPL-2.0 */
|
/*
|
* Neighbor Awareness Networking
|
*
|
* Copyright (C) 1999-2019, 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.
|
*
|
* <<Broadcom-WL-IPTag/Open:>>
|
*
|
* $Id: wl_cfgnan.c 559906 2015-05-29 02:42:35Z $
|
*/
|
|
#include <bcmutils.h>
|
#include <bcmendian.h>
|
#include <bcmwifi_channels.h>
|
#include <proto/nan.h>
|
|
#include <wl_cfg80211.h>
|
#include <wl_android.h>
|
#include <wl_cfgnan.h>
|
|
#ifdef WL_NAN_DEBUG
|
static u8 g_nan_debug = true;
|
#endif /* WL_NAN_DEBUG */
|
|
static nan_cmd_t nan_cmds [] = {
|
{ "NAN_START", wl_cfgnan_start_handler },
|
{ "NAN_STOP", wl_cfgnan_stop_handler },
|
{ "NAN_SUPPORT", wl_cfgnan_support_handler },
|
{ "NAN_STATUS", wl_cfgnan_status_handler },
|
{ "NAN_PUBLISH", wl_cfgnan_pub_handler },
|
{ "NAN_SUBSCRIBE", wl_cfgnan_sub_handler },
|
{ "NAN_CANCEL_PUBLISH", wl_cfgnan_cancel_pub_handler },
|
{ "NAN_CANCEL_SUBSCRIBE", wl_cfgnan_cancel_sub_handler },
|
{ "NAN_TRANSMIT", wl_cfgnan_transmit_handler },
|
{ "NAN_SET_CONFIG", wl_cfgnan_set_config_handler },
|
{ "NAN_GET_CONFIG", NULL },
|
{ "NAN_RTT_CONFIG", wl_cfgnan_rtt_config_handler },
|
{ "NAN_RTT_FIND", wl_cfgnan_rtt_find_handler },
|
#ifdef WL_NAN_DEBUG
|
{ "NAN_DEBUG", wl_cfgnan_debug_handler },
|
#endif /* WL_NAN_DEBUG */
|
#ifdef NAN_P2P_CONFIG
|
{ "NAN_ADD_CONF", wl_cfgnan_p2p_ie_add_handler },
|
{ "NAN_ENABLE_CONF", wl_cfgnan_p2p_ie_enable_handler },
|
{ "NAN_DEL_CONF", wl_cfgnan_p2p_ie_del_handler },
|
#endif /* NAN_P2P_CONFIG */
|
{ NULL, NULL },
|
};
|
|
static nan_config_attr_t nan_config_attrs [] = {
|
{ "ATTR_MASTER", WL_NAN_XTLV_MASTER_PREF },
|
{ "ATTR_ID", WL_NAN_XTLV_CLUSTER_ID },
|
{ "ATTR_ADDR", WL_NAN_XTLV_IF_ADDR },
|
{ "ATTR_ROLE", WL_NAN_XTLV_ROLE },
|
{ "ATTR_BCN_INT", WL_NAN_XTLV_BCN_INTERVAL },
|
{ "ATTR_CHAN", WL_NAN_XTLV_MAC_CHANSPEC },
|
{ "ATTR_TX_RATE", WL_NAN_XTLV_MAC_TXRATE },
|
{ "ATTR_DW_LEN", WL_NAN_XTLV_DW_LEN },
|
{ {0}, 0 }
|
};
|
|
#ifdef WL_NAN_DEBUG
|
void print_event_name(u32 event_num)
|
{
|
char *event_name = NULL;
|
|
switch (event_num) {
|
case WL_NAN_EVENT_START:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_START);
|
break;
|
case WL_NAN_EVENT_JOIN:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_JOIN);
|
break;
|
case WL_NAN_EVENT_ROLE:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_ROLE);
|
break;
|
case WL_NAN_EVENT_SCAN_COMPLETE:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_SCAN_COMPLETE);
|
break;
|
case WL_NAN_EVENT_DISCOVERY_RESULT:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_DISCOVERY_RESULT);
|
break;
|
case WL_NAN_EVENT_REPLIED:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_REPLIED);
|
break;
|
case WL_NAN_EVENT_TERMINATED:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_TERMINATED);
|
break;
|
case WL_NAN_EVENT_RECEIVE:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_RECEIVE);
|
break;
|
case WL_NAN_EVENT_STATUS_CHG:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_STATUS_CHG);
|
break;
|
case WL_NAN_EVENT_MERGE:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_MERGE);
|
break;
|
case WL_NAN_EVENT_STOP:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_STOP);
|
break;
|
case WL_NAN_EVENT_P2P:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_P2P);
|
break;
|
case WL_NAN_EVENT_WINDOW_BEGIN_P2P:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_WINDOW_BEGIN_P2P);
|
break;
|
case WL_NAN_EVENT_WINDOW_BEGIN_MESH:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_WINDOW_BEGIN_MESH);
|
break;
|
case WL_NAN_EVENT_WINDOW_BEGIN_IBSS:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_WINDOW_BEGIN_IBSS);
|
break;
|
case WL_NAN_EVENT_WINDOW_BEGIN_RANGING:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_WINDOW_BEGIN_RANGING);
|
break;
|
case WL_NAN_EVENT_INVALID:
|
event_name = NAME_TO_STR(WL_NAN_EVENT_INVALID);
|
break;
|
default:
|
break;
|
}
|
if (event_name) {
|
WL_DBG((" event name: %s \n", event_name));
|
} else {
|
WL_DBG(("Unknown event %d\n", event_num));
|
}
|
}
|
#endif /* WL_NAN_DEBUG */
|
|
int
|
wl_cfgnan_set_vars_cbfn(void *ctx, uint8 *buf, uint16 type, uint16 len)
|
{
|
wl_nan_tlv_data_t *ndata = ((wl_nan_tlv_data_t *)(ctx));
|
int ret = BCME_OK;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
|
WL_DBG((" enter, xtlv_type: 0x%x \n", type));
|
|
switch (type) {
|
case WL_NAN_XTLV_ENABLED:
|
memcpy(&ndata->enabled, buf, len);
|
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
|
*/
|
memcpy(&ndata->master_pref, buf, len);
|
break;
|
case WL_NAN_XTLV_IF_ADDR:
|
memcpy(&ndata->mac_addr, buf, len);
|
break;
|
case WL_NAN_XTLV_CLUSTER_ID:
|
memcpy(&ndata->clus_id, buf, len);
|
break;
|
case WL_NAN_XTLV_ROLE:
|
/* nan device role, master, master-sync nosync etc */
|
memcpy(&ndata->dev_role, buf, len);
|
break;
|
case WL_NAN_XTLV_MAC_CHANSPEC:
|
memcpy(&ndata->chanspec, buf, len);
|
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:
|
memcpy(ndata->amr, buf, len);
|
break;
|
case WL_NAN_XTLV_MAC_AMBTT:
|
memcpy(&ndata->ambtt, buf, len);
|
break;
|
case WL_NAN_XTLV_MAC_HOPCNT:
|
memcpy(&ndata->hop_count, buf, len);
|
break;
|
case WL_NAN_XTLV_INSTANCE_ID:
|
memcpy(&ndata->inst_id, buf, len);
|
break;
|
case WL_NAN_XTLV_SVC_NAME:
|
memcpy(ndata->svc_name, buf, len);
|
break;
|
case WL_NAN_XTLV_SVC_PARAMS:
|
memcpy(&ndata->params, buf, len);
|
break;
|
case WL_NAN_XTLV_MAC_STATUS:
|
memcpy(&ndata->nstatus, buf, len);
|
break;
|
case WL_NAN_XTLV_PUBLR_ID:
|
memcpy(&ndata->pub_id, buf, len);
|
break;
|
case WL_NAN_XTLV_SUBSCR_ID:
|
memcpy(&ndata->sub_id, buf, len);
|
break;
|
case WL_NAN_XTLV_MAC_ADDR:
|
memcpy(&ndata->mac_addr, buf, len);
|
break;
|
case WL_NAN_XTLV_VNDR:
|
ndata->vend_info.dlen = len;
|
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) {
|
memcpy(ndata->vend_info.data, buf, len);
|
}
|
break;
|
case WL_NAN_XTLV_SVC_INFO:
|
ndata->svc_info.dlen = len;
|
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) {
|
memcpy(ndata->svc_info.data, buf, len);
|
}
|
break;
|
case WL_NAN_XTLV_PEER_INSTANCE_ID:
|
memcpy(&ndata->peer_inst_id, buf, len);
|
break;
|
case WL_NAN_XTLV_NAN_SCANPARAMS:
|
memcpy(&ndata->scan_params, buf, len);
|
break;
|
case WL_NAN_XTLV_ZERO:
|
/* don't parse empty space in the buffer */
|
ret = BCME_ERROR;
|
break;
|
|
default:
|
break;
|
}
|
|
fail:
|
return ret;
|
}
|
|
int
|
wl_cfgnan_enable_events(struct net_device *ndev, struct bcm_cfg80211 *cfg)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
uint8 *pxtlv;
|
u32 event_mask = 0;
|
s32 ret = BCME_OK;
|
u16 start, end;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
ret = wl_add_remove_eventmsg(ndev, WLC_E_NAN, true);
|
if (unlikely(ret)) {
|
WL_ERR((" nan event enable failed, error = %d \n", ret));
|
goto fail;
|
}
|
#ifdef WL_NAN_DEBUG
|
if (g_nan_debug) {
|
/* enable all nan events */
|
event_mask = NAN_EVENT_MASK_ALL;
|
} else
|
#endif /* WL_NAN_DEBUG */
|
{
|
/* enable only selected nan events to avoid unnecessary host wake up */
|
event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_START);
|
event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_JOIN);
|
event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_DISCOVERY_RESULT);
|
event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_RECEIVE);
|
event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_TERMINATED);
|
event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_STOP);
|
event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_CLEAR_BIT);
|
#ifdef NAN_P2P_CONFIG
|
event_mask |= NAN_EVENT_BIT(WL_NAN_EVENT_P2P);
|
#endif /* NAN_P2P_CONFIG */
|
event_mask = htod32(event_mask);
|
}
|
|
start = end = NAN_IOCTL_BUF_SIZE;
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_EVENT_MASK);
|
pxtlv = nanioc->data;
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_EVENT_MASK,
|
sizeof(event_mask), &event_mask, BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
nanioc->len = start - end;
|
nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;
|
ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan event selective enable failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
WL_DBG((" nan event selective enable successful \n"));
|
}
|
|
ret = wl_add_remove_eventmsg(ndev, WLC_E_PROXD, true);
|
if (unlikely(ret)) {
|
WL_ERR((" proxd event enable failed, error = %d \n", ret));
|
goto fail;
|
}
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_enable_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
uint8 *pxtlv;
|
s32 ret = BCME_OK;
|
u16 start, end;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
uint8 val;
|
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
/*
|
* command to test
|
*
|
* wl: wl nan 1
|
*
|
* wpa_cli: DRIVER NAN_ENABLE
|
*/
|
|
/* nan enable */
|
val = 1;
|
start = end = NAN_IOCTL_BUF_SIZE;
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_ENABLE);
|
pxtlv = nanioc->data;
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_ENABLED,
|
sizeof(val), &val, BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
nanioc->len = start - end;
|
nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;
|
ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan enable failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
cfg->nan_enable = true;
|
WL_DBG((" nan enable successful \n"));
|
}
|
|
/* enable nan events */
|
ret = wl_cfgnan_enable_events(ndev, cfg);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_start_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
struct ether_addr cluster_id = ether_null;
|
uint8 *pxtlv;
|
s32 ret = BCME_OK;
|
u16 start, end;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
uint8 val;
|
|
if (cfg->nan_enable != true) {
|
ret = wl_cfgnan_enable_handler(ndev, cfg, cmd, cmd_data);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
}
|
|
/*
|
* command to test
|
*
|
* wl: wl nan join -start
|
*
|
* wpa_cli: DRIVER NAN_START
|
*/
|
|
/* nan join */
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
val = 1;
|
start = end = NAN_IOCTL_BUF_SIZE;
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_NAN_JOIN);
|
pxtlv = nanioc->data;
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_CLUSTER_ID,
|
ETHER_ADDR_LEN, &cluster_id, BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_START,
|
sizeof(val), &val, BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
nanioc->len = start - end;
|
nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;
|
ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan join failed, error = %d \n", ret));
|
goto fail;
|
}
|
|
WL_DBG((" nan join successful \n"));
|
cfg->nan_running = true;
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_stop_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
struct ether_addr cluster_id = ether_null;
|
uint8 *pxtlv;
|
s32 ret = BCME_OK;
|
u16 start, end;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
uint8 nan_enable = FALSE;
|
|
/*
|
* command to test
|
*
|
* wl: wl nan stop
|
* wl nan 0
|
*
|
* wpa_cli: DRIVER NAN_STOP
|
*/
|
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
if (cfg->nan_running == true) {
|
/* nan stop */
|
|
start = end = NAN_IOCTL_BUF_SIZE;
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_STOP);
|
pxtlv = nanioc->data;
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_CLUSTER_ID,
|
ETHER_ADDR_LEN, &cluster_id, BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
nanioc->len = start - end;
|
nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;
|
ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan stop failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
cfg->nan_running = false;
|
WL_DBG((" nan stop successful \n"));
|
}
|
}
|
|
/* nan disable */
|
if (cfg->nan_enable == true) {
|
memset(nanioc, 0, nanioc_size);
|
start = end = NAN_IOCTL_BUF_SIZE;
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_ENABLE);
|
pxtlv = nanioc->data;
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_ENABLED,
|
sizeof(nan_enable), &nan_enable, BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
nanioc->len = start - end;
|
nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;
|
ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan disable failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
cfg->nan_enable = false;
|
WL_DBG((" nan disable successful \n"));
|
}
|
}
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_support_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
uint8 *pxtlv;
|
s32 ret = BCME_OK;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
/*
|
* command to test
|
*
|
* wl: wl nan
|
*
|
* wpa_cli: DRIVER NAN_SUPPORT
|
*/
|
|
/* nan support */
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_ENABLE);
|
pxtlv = nanioc->data;
|
nanioc->len = htod16(BCM_XTLV_HDR_SIZE + 1);
|
nanioc_size = sizeof(wl_nan_ioc_t) + sizeof(bcm_xtlv_t);
|
ret = wldev_iovar_getbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_SMLEN, &cfg->ioctl_buf_sync);
|
if (unlikely(ret)) {
|
WL_ERR((" nan is not supported, error = %d \n", ret));
|
goto fail;
|
} else {
|
WL_DBG((" nan is supported \n"));
|
}
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_status_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
wl_nan_ioc_t *ioc_ret = NULL;
|
char *ptr = cmd;
|
char *end = cmd + size;
|
wl_nan_tlv_data_t tlv_data;
|
s32 ret = BCME_OK;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
/*
|
* command to test
|
*
|
* wl: wl nan status
|
*
|
* wpa_cli: DRIVER NAN_STATUS
|
*/
|
|
/* nan status */
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_STATUS);
|
nanioc->len = NAN_IOCTL_BUF_SIZE;
|
nanioc_size = sizeof(wl_nan_ioc_t) + sizeof(bcm_xtlv_t);
|
ret = wldev_iovar_getbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan status failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
WL_DBG((" nan status successful \n"));
|
}
|
|
/* unpack the tlvs */
|
memset(&tlv_data, 0, sizeof(tlv_data));
|
ioc_ret = (wl_nan_ioc_t *)cfg->ioctl_buf;
|
if (!ioc_ret) {
|
goto fail;
|
}
|
#ifdef WL_NAN_DEBUG
|
if (g_nan_debug) {
|
prhex(" nanioc->data: ", (uint8 *)ioc_ret->data, ioc_ret->len);
|
}
|
#endif /* WL_NAN_DEBUG */
|
bcm_unpack_xtlv_buf(&tlv_data, ioc_ret->data, ioc_ret->len,
|
BCM_XTLV_OPTION_ALIGN32, wl_cfgnan_set_vars_cbfn);
|
|
ptr += snprintf(ptr, end-ptr, ROLE_PREFIX"%d", tlv_data.dev_role);
|
ptr += snprintf(ptr, end-ptr, " " AMR_PREFIX);
|
ptr += bcm_format_hex(ptr, tlv_data.amr, NAN_MASTER_RANK_LEN);
|
ptr += snprintf(ptr, end-ptr, " " CLUS_ID_PREFIX MACF, ETHER_TO_MACF(tlv_data.clus_id));
|
ptr += snprintf(ptr, end-ptr, " " AMBTT_PREFIX"0x%x", tlv_data.ambtt);
|
ptr += snprintf(ptr, end-ptr, " " HOP_COUNT_PREFIX"%d", tlv_data.hop_count);
|
|
/* nan scan param */
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_SCAN_PARAMS);
|
nanioc->len = NAN_IOCTL_BUF_SIZE;
|
nanioc_size = sizeof(wl_nan_ioc_t) + sizeof(bcm_xtlv_t);
|
ret = wldev_iovar_getbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan scan params failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
WL_DBG((" nan scan params successful \n"));
|
}
|
|
if (tlv_data.svc_info.data) {
|
kfree(tlv_data.svc_info.data);
|
tlv_data.svc_info.data = NULL;
|
tlv_data.svc_info.dlen = 0;
|
}
|
if (tlv_data.vend_info.data) {
|
kfree(tlv_data.vend_info.data);
|
tlv_data.vend_info.data = NULL;
|
tlv_data.vend_info.dlen = 0;
|
}
|
/* unpack the tlvs */
|
memset(&tlv_data, 0, sizeof(tlv_data));
|
ioc_ret = (wl_nan_ioc_t *)cfg->ioctl_buf;
|
ASSERT(ioc_ret != NULL);
|
#ifdef WL_NAN_DEBUG
|
if (g_nan_debug) {
|
prhex(" nanioc->data: ", (uint8 *)ioc_ret->data, ioc_ret->len);
|
}
|
#endif /* WL_NAN_DEBUG */
|
bcm_unpack_xtlv_buf(&tlv_data, ioc_ret->data, ioc_ret->len,
|
BCM_XTLV_OPTION_ALIGN32, wl_cfgnan_set_vars_cbfn);
|
|
ptr += snprintf(ptr, end-ptr, " " SCAN_PERIOD_PREFIX"%d",
|
tlv_data.scan_params.ms_dur);
|
ptr += snprintf(ptr, end-ptr, " " SCAN_INTERVAL_PREFIX"%d",
|
tlv_data.scan_params.ms_intvl*512);
|
|
if (ptr > end) {
|
WL_ERR(("Buffer overflow. userspace string truncated: %s, len: %zu\n",
|
cmd, strlen(cmd)));
|
}
|
|
WL_DBG((" formatted string for userspace: %s, len: %zu \n",
|
cmd, strlen(cmd)));
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
if (tlv_data.svc_info.data) {
|
kfree(tlv_data.svc_info.data);
|
tlv_data.svc_info.data = NULL;
|
tlv_data.svc_info.dlen = 0;
|
}
|
if (tlv_data.vend_info.data) {
|
kfree(tlv_data.vend_info.data);
|
tlv_data.vend_info.data = NULL;
|
tlv_data.vend_info.dlen = 0;
|
}
|
|
return ret;
|
}
|
|
|
#ifdef NAN_P2P_CONFIG
|
|
static void
|
wl_p2p_nan_ioctl_make_header(wl_p2p_nan_ioc_t *p2p_nanioc, uint16 cmd_id, uint16 len)
|
{
|
p2p_nanioc->version = htod16(WL_P2P_NAN_IOCTL_VERSION);
|
p2p_nanioc->id = cmd_id;
|
p2p_nanioc->len = htod16(len);
|
}
|
|
static int
|
wl_p2p_nan_do_get_ioctl(struct net_device *ndev, struct bcm_cfg80211 *cfg,
|
wl_p2p_nan_ioc_t *p2p_nanioc, uint16 alloc_size)
|
{
|
wl_p2p_nan_ioc_t *iocresp = NULL;
|
int res;
|
uint8 *val;
|
/* send getbuf p2p nan iovar */
|
res = wldev_iovar_getbuf(ndev, "p2p_nan", p2p_nanioc, alloc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
|
if (res == BCME_OK) {
|
iocresp = (wl_p2p_nan_ioc_t *)cfg->ioctl_buf;
|
if (iocresp == NULL) {
|
res = BCME_ERROR;
|
return res;
|
}
|
switch (iocresp->id) {
|
case WL_P2P_NAN_CMD_ENABLE:
|
val = iocresp->data;
|
WL_ERR(("wl p2p_nan status is %s\n",
|
*val == 1? "Enabled":"Disabled"));
|
break;
|
case WL_P2P_NAN_CMD_CONFIG: {
|
wl_p2p_nan_config_t *p_p2p_nan_cfg =
|
(wl_p2p_nan_config_t *)iocresp->data;
|
WL_ERR(("wl p2p nan ie len = %u\n", p_p2p_nan_cfg->ie_len));
|
prhex("P2P IE", p_p2p_nan_cfg->ie, p_p2p_nan_cfg->ie_len);
|
}
|
break;
|
default:
|
WL_ERR(("Unknown command %d\n", iocresp->id));
|
break;
|
}
|
}
|
return res;
|
}
|
|
|
int wl_cfgnan_p2p_ie_enable_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char* buf, int size, nan_cmd_data_t *cmd_data)
|
{
|
int res = BCME_OK;
|
wl_p2p_nan_ioc_t *p2p_nanioc;
|
uint16 alloc_size = OFFSETOF(wl_p2p_nan_ioc_t, data) + P2P_NAN_IOC_BUFSZ;
|
void *pdata = NULL;
|
uint8 val;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
p2p_nanioc = kzalloc(alloc_size, kflags);
|
if (p2p_nanioc == NULL) {
|
WL_ERR((" memory allocation failed \n"));
|
return BCME_NOMEM;
|
}
|
|
wl_p2p_nan_ioctl_make_header(p2p_nanioc, WL_P2P_NAN_CMD_ENABLE, sizeof(uint8));
|
|
if (cmd_data->p2p_info.data == NULL) { /* get */
|
res = wl_p2p_nan_do_get_ioctl(ndev, cfg, p2p_nanioc, alloc_size);
|
} else { /* set */
|
|
val = (uint8) cmd_data->p2p_info.data[0];
|
pdata = p2p_nanioc->data;
|
memcpy(pdata, &val, sizeof(uint8));
|
res = wldev_iovar_setbuf(ndev, "p2p_nan", p2p_nanioc,
|
alloc_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
}
|
|
kfree(p2p_nanioc);
|
return res;
|
}
|
int wl_cfgnan_p2p_ie_add_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
int res = BCME_OK;
|
int ie_len, data_len;
|
wl_p2p_nan_ioc_t *p2p_nanioc;
|
uint16 alloc_size = OFFSETOF(wl_p2p_nan_ioc_t, data) + cmd_data->p2p_info.dlen;
|
wl_p2p_nan_config_t *p_p2p_nan_cfg;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
|
p2p_nanioc = kzalloc(alloc_size, kflags);
|
if (p2p_nanioc == NULL)
|
return BCME_NOMEM;
|
|
cmd_data->p2p_info.dlen /= 2; /* Number of hex values will be half of ascii */
|
wl_p2p_nan_ioctl_make_header(p2p_nanioc, WL_P2P_NAN_CMD_CONFIG, P2P_NAN_IOC_BUFSZ);
|
|
if (cmd_data->p2p_info.data == NULL) { /* get */
|
wl_p2p_nan_do_get_ioctl(ndev, cfg, p2p_nanioc, alloc_size);
|
} else {
|
ie_len = cmd_data->p2p_info.dlen;
|
data_len = OFFSETOF(wl_p2p_nan_config_t, ie) + ie_len;
|
|
p_p2p_nan_cfg = (wl_p2p_nan_config_t *)p2p_nanioc->data;
|
p_p2p_nan_cfg->version = WL_P2P_NAN_CONFIG_VERSION;
|
p_p2p_nan_cfg->len = data_len;
|
p_p2p_nan_cfg->ie_len = ie_len;
|
|
if (!wl_cfg80211_hex_str_to_bin
|
(p_p2p_nan_cfg->ie, (int)p_p2p_nan_cfg->ie_len, (uchar*)cmd_data->p2p_info.data)) {
|
res = BCME_BADARG;
|
goto fail;
|
}
|
p2p_nanioc->len = htod16(data_len);
|
|
res = wldev_iovar_setbuf(ndev, "p2p_nan", p2p_nanioc, alloc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
}
|
fail:
|
kfree(p2p_nanioc);
|
return res;
|
}
|
int wl_cfgnan_p2p_ie_del_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
int res = BCME_OK;
|
wl_p2p_nan_ioc_t *p2p_nanioc;
|
uint16 alloc_size = OFFSETOF(wl_p2p_nan_ioc_t, data);
|
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
p2p_nanioc = kzalloc(alloc_size, kflags);
|
if (p2p_nanioc == NULL) {
|
WL_ERR((" Memory is not enough\n"));
|
return BCME_NOMEM;
|
}
|
wl_p2p_nan_ioctl_make_header(p2p_nanioc, WL_P2P_NAN_CMD_DEL_CONFIG, 0);
|
res = wldev_iovar_setbuf(ndev, "p2p_nan", p2p_nanioc, alloc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
kfree(p2p_nanioc);
|
return res;
|
}
|
|
#endif /* NAN_P2P_CONFIG */
|
|
/*
|
* packs user data (in hex string) into tlv record
|
* advances tlv pointer to next xtlv slot
|
* buflen is used for tlv_buf space check
|
*/
|
static int
|
get_ie_data(uchar *data_str, uchar *ie_data, int len)
|
{
|
uchar *src, *dest;
|
uchar val;
|
int idx;
|
char hexstr[3];
|
|
src = data_str;
|
dest = ie_data;
|
|
for (idx = 0; idx < len; idx++) {
|
hexstr[0] = src[0];
|
hexstr[1] = src[1];
|
hexstr[2] = '\0';
|
|
#ifdef BCMDRIVER
|
val = (uchar) simple_strtoul(hexstr, NULL, 16);
|
#else
|
val = (uchar) strtoul(hexstr, NULL, 16);
|
#endif
|
|
*dest++ = val;
|
src += 2;
|
}
|
|
return 0;
|
}
|
|
int
|
wl_cfgnan_pub_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
wl_nan_disc_params_t params;
|
s32 ret = BCME_OK;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
uint8 *pxtlv;
|
u16 start, end;
|
uchar *buf = NULL;
|
|
/*
|
* proceed only if mandatory arguments are present - publisher id,
|
* service hash
|
*/
|
if ((!cmd_data->pub_id) || (!cmd_data->svc_hash.data) ||
|
(!cmd_data->svc_hash.dlen)) {
|
WL_ERR((" mandatory arguments are not present \n"));
|
return -EINVAL;
|
}
|
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
/*
|
* command to test
|
*
|
* wl: wl nan publish 10 NAN123 -info <hex_string
|
* wl nan publish 10 NAN123 -info <hex_string -period 1 -ttl 0xffffffff
|
*
|
* wpa_cli: DRIVER NAN_PUBLISH PUB_ID=10 SVC_HASH=NAN123
|
* SVC_INFO=<hex_string>
|
* DRIVER NAN_PUBLISH PUB_ID=10 SVC_HASH=NAN123
|
* SVC_INFO=<hex_string> PUB_PR=1 PUB_INT=0xffffffff
|
*/
|
|
/* nan publish */
|
start = end = NAN_IOCTL_BUF_SIZE;
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_PUBLISH);
|
pxtlv = nanioc->data;
|
|
/* disovery parameters */
|
if (cmd_data->pub_pr) {
|
params.period = cmd_data->pub_pr;
|
} else {
|
params.period = 1;
|
}
|
if (cmd_data->pub_int) {
|
params.ttl = cmd_data->pub_int;
|
} else {
|
params.ttl = WL_NAN_TTL_UNTIL_CANCEL;
|
}
|
params.flags = 0;
|
if (cmd_data->flags & WL_NAN_PUB_UNSOLICIT) {
|
params.flags |= WL_NAN_PUB_UNSOLICIT;
|
WL_DBG((" nan publish type - unsolicited\n"));
|
}
|
if (cmd_data->flags & WL_NAN_PUB_SOLICIT) {
|
params.flags |= WL_NAN_PUB_SOLICIT;
|
WL_DBG((" nan publish type - solicited\n"));
|
}
|
if (!params.flags) {
|
params.flags = WL_NAN_PUB_BOTH; /* default. */
|
}
|
params.instance_id = (wl_nan_instance_id_t)cmd_data->pub_id;
|
memcpy((char *)params.svc_hash, cmd_data->svc_hash.data,
|
cmd_data->svc_hash.dlen);
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_SVC_PARAMS,
|
sizeof(params), ¶ms, BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
if (cmd_data->svc_info.data && cmd_data->svc_info.dlen) {
|
uint16 len = cmd_data->svc_info.dlen/2;
|
|
WL_DBG((" optional svc_info present, pack it \n"));
|
buf = kzalloc(len, kflags);
|
if (!buf) {
|
WL_ERR((" memory allocation failed \n"));
|
ret = -ENOMEM;
|
goto fail;
|
}
|
if (get_ie_data((uchar*)cmd_data->svc_info.data, buf, len)) {
|
goto fail;
|
}
|
|
ret = bcm_pack_xtlv_entry(&pxtlv,
|
&end, WL_NAN_XTLV_SVC_INFO, len, buf, BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
}
|
|
nanioc->len = start - end;
|
nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;
|
ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan publish failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
WL_DBG((" nan publish successful \n"));
|
}
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
if (buf) {
|
kfree(buf);
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_sub_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
bcm_xtlvbuf_t tbuf;
|
wl_nan_disc_params_t params;
|
s32 ret = BCME_OK;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
|
/*
|
* proceed only if mandatory arguments are present - subscriber id,
|
* service hash
|
*/
|
if ((!cmd_data->sub_id) || (!cmd_data->svc_hash.data) ||
|
(!cmd_data->svc_hash.dlen)) {
|
WL_ERR((" mandatory arguments are not present \n"));
|
return -EINVAL;
|
}
|
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
bcm_xtlv_buf_init(&tbuf, nanioc->data,
|
BCM_XTLV_HDR_SIZE + sizeof(params), BCM_XTLV_OPTION_ALIGN32);
|
|
/*
|
* command to test
|
*
|
* wl: wl nan subscribe 10 NAN123
|
*
|
* wpa_cli: DRIVER NAN_SUBSCRIBE SUB_ID=10 SVC_HASH=NAN123
|
*/
|
|
/* nan subscribe */
|
params.period = 1;
|
params.ttl = WL_NAN_TTL_UNTIL_CANCEL;
|
params.flags = 0;
|
if (cmd_data->flags & WL_NAN_SUB_ACTIVE) {
|
params.flags = WL_NAN_SUB_ACTIVE;
|
WL_DBG((" nan subscribe type - Active\n"));
|
}
|
params.instance_id = (wl_nan_instance_id_t)cmd_data->sub_id;
|
memcpy((char *)params.svc_hash, cmd_data->svc_hash.data,
|
cmd_data->svc_hash.dlen);
|
bcm_xtlv_put_data(&tbuf, WL_NAN_XTLV_SVC_PARAMS, ¶ms, sizeof(params));
|
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_SUBSCRIBE);
|
nanioc->len = htod16(bcm_xtlv_buf_len(&tbuf));
|
nanioc_size = sizeof(wl_nan_ioc_t) + bcm_xtlv_buf_len(&tbuf);
|
ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan subscribe failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
WL_DBG((" nan subscribe successful \n"));
|
}
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_cancel_pub_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
bcm_xtlvbuf_t tbuf;
|
wl_nan_disc_params_t params;
|
s32 ret = BCME_OK;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
|
/* proceed only if mandatory argument is present - publisher id */
|
if (!cmd_data->pub_id) {
|
WL_ERR((" mandatory argument is not present \n"));
|
return -EINVAL;
|
}
|
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
bcm_xtlv_buf_init(&tbuf, nanioc->data,
|
BCM_XTLV_HDR_SIZE + sizeof(params), BCM_XTLV_OPTION_ALIGN32);
|
|
/*
|
* command to test
|
*
|
* wl: wl nan cancel_publish 10
|
*
|
* wpa_cli: DRIVER NAN_CANCEL_PUBLISH PUB_ID=10
|
*/
|
|
bcm_xtlv_put_data(&tbuf, WL_NAN_XTLV_INSTANCE_ID, &cmd_data->pub_id,
|
sizeof(wl_nan_instance_id_t));
|
|
/* nan cancel publish */
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_CANCEL_PUBLISH);
|
nanioc->len = htod16(bcm_xtlv_buf_len(&tbuf));
|
nanioc_size = sizeof(wl_nan_ioc_t) + bcm_xtlv_buf_len(&tbuf);
|
ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan cancel publish failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
WL_DBG((" nan cancel publish successful \n"));
|
}
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_cancel_sub_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
bcm_xtlvbuf_t tbuf;
|
wl_nan_disc_params_t params;
|
s32 ret = BCME_OK;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
|
/* proceed only if mandatory argument is present - subscriber id */
|
if (!cmd_data->sub_id) {
|
WL_ERR((" mandatory argument is not present \n"));
|
return -EINVAL;
|
}
|
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
bcm_xtlv_buf_init(&tbuf, nanioc->data,
|
BCM_XTLV_HDR_SIZE + sizeof(params), BCM_XTLV_OPTION_ALIGN32);
|
|
/*
|
* command to test
|
*
|
* wl: wl nan cancel_subscribe 10
|
*
|
* wpa_cli: DRIVER NAN_CANCEL_SUBSCRIBE PUB_ID=10
|
*/
|
|
bcm_xtlv_put_data(&tbuf, WL_NAN_XTLV_INSTANCE_ID, &cmd_data->sub_id,
|
sizeof(wl_nan_instance_id_t));
|
|
/* nan cancel subscribe */
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_CANCEL_SUBSCRIBE);
|
nanioc->len = htod16(bcm_xtlv_buf_len(&tbuf));
|
nanioc_size = sizeof(wl_nan_ioc_t) + bcm_xtlv_buf_len(&tbuf);
|
ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan cancel subscribe failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
WL_DBG((" nan cancel subscribe successful \n"));
|
}
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_transmit_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
uint8 *pxtlv;
|
s32 ret = BCME_OK;
|
u16 start, end;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
uchar *buf = NULL;
|
|
/*
|
* proceed only if mandatory arguments are present - subscriber id,
|
* publisher id, mac address
|
*/
|
if ((!cmd_data->local_id) || (!cmd_data->remote_id) ||
|
ETHER_ISNULLADDR(&cmd_data->mac_addr.octet)) {
|
WL_ERR((" mandatory arguments are not present \n"));
|
return -EINVAL;
|
}
|
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
/*
|
* command to test
|
*
|
* wl: wl nan trasnmit <sub_id> <pub_id> <mac_addr> -info <hex_string>
|
*
|
* wpa_cli: DRIVER NAN_TRANSMIT SUB_ID=<sub_id> PUB_ID=<pub_id>
|
* MAC_ADDR=<mac_addr> SVC_INFO=<hex_string>
|
*/
|
|
/* nan transmit */
|
start = end = NAN_IOCTL_BUF_SIZE;
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_TRANSMIT);
|
pxtlv = nanioc->data;
|
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_INSTANCE_ID,
|
sizeof(cmd_data->local_id), &cmd_data->local_id,
|
BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_REQUESTOR_ID,
|
sizeof(cmd_data->remote_id), &cmd_data->remote_id,
|
BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_MAC_ADDR,
|
ETHER_ADDR_LEN, &cmd_data->mac_addr.octet,
|
BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
if (cmd_data->svc_info.data && cmd_data->svc_info.dlen) {
|
uint16 len = cmd_data->svc_info.dlen/2;
|
|
WL_DBG((" optional svc_info present, pack it \n"));
|
buf = kzalloc(len, kflags);
|
if (!buf) {
|
WL_ERR((" memory allocation failed \n"));
|
ret = -ENOMEM;
|
goto fail;
|
}
|
if (get_ie_data((uchar*)cmd_data->svc_info.data, buf, len)) {
|
goto fail;
|
}
|
|
ret = bcm_pack_xtlv_entry(&pxtlv,
|
&end, WL_NAN_XTLV_SVC_INFO, len, buf,
|
BCM_XTLV_OPTION_ALIGN32);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
}
|
|
nanioc->len = start - end;
|
nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;
|
ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan transmit failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
WL_DBG((" nan transmit successful \n"));
|
}
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
if (buf) {
|
kfree(buf);
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_set_config_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ioc_t *nanioc = NULL;
|
uint8 *pxtlv;
|
s32 ret = BCME_OK;
|
u16 start, end;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
uint16 nanioc_size = sizeof(wl_nan_ioc_t) + NAN_IOCTL_BUF_SIZE;
|
|
if (cfg->nan_running == true) {
|
WL_ERR((" Stop nan (NAN_STOP) before issuing NAN_CONFIG command\n"));
|
return BCME_ERROR;
|
}
|
|
if (cfg->nan_enable != true) {
|
ret = wl_cfgnan_enable_handler(ndev, cfg, cmd, cmd_data);
|
if (unlikely(ret)) {
|
goto fail;
|
}
|
}
|
|
nanioc = kzalloc(nanioc_size, kflags);
|
if (!nanioc) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
/*
|
* command to test
|
*
|
* wl: wl nan <attr> <value> (wl nan role 1)
|
*
|
* wpa_cli: DRIVER NAN_CONFIG_SET ATTR=<attr> <value>...<value>
|
*
|
* wpa_cli: DRIVER NAN_SET_CONFIG ATTR=ATTR_ROLE ROLE=1
|
*/
|
|
/* nan set config */
|
start = end = NAN_IOCTL_BUF_SIZE;
|
nanioc->version = htod16(WL_NAN_IOCTL_VERSION);
|
nanioc->id = htod16(WL_NAN_CMD_ATTR);
|
pxtlv = nanioc->data;
|
|
switch (cmd_data->attr.type) {
|
case WL_NAN_XTLV_ROLE:
|
WL_DBG((" set nan ROLE = %#x\n", cmd_data->role));
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_ROLE,
|
sizeof(cmd_data->role), &cmd_data->role,
|
BCM_XTLV_OPTION_ALIGN32);
|
break;
|
case WL_NAN_XTLV_MASTER_PREF:
|
WL_DBG((" set nan MASTER PREF = %#x\n", cmd_data->master_pref));
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_MASTER_PREF,
|
sizeof(cmd_data->master_pref), &cmd_data->master_pref,
|
BCM_XTLV_OPTION_ALIGN32);
|
break;
|
case WL_NAN_XTLV_DW_LEN:
|
WL_DBG((" set nan DW LEN = %#x\n", cmd_data->dw_len));
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_DW_LEN,
|
sizeof(cmd_data->dw_len), &cmd_data->dw_len,
|
BCM_XTLV_OPTION_ALIGN32);
|
break;
|
case WL_NAN_XTLV_CLUSTER_ID:
|
WL_DBG((" set nan CLUSTER ID "));
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_CLUSTER_ID,
|
sizeof(cmd_data->clus_id), &cmd_data->clus_id,
|
BCM_XTLV_OPTION_ALIGN32);
|
break;
|
case WL_NAN_XTLV_IF_ADDR:
|
WL_DBG((" set nan IFADDR "));
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_IF_ADDR,
|
sizeof(cmd_data->if_addr), &cmd_data->if_addr,
|
BCM_XTLV_OPTION_ALIGN32);
|
break;
|
case WL_NAN_XTLV_MAC_CHANSPEC:
|
WL_DBG((" set nan CHANSPEC = %#x\n", cmd_data->chanspec));
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_MAC_CHANSPEC,
|
sizeof(cmd_data->chanspec), &cmd_data->chanspec,
|
BCM_XTLV_OPTION_ALIGN32);
|
break;
|
case WL_NAN_XTLV_BCN_INTERVAL:
|
WL_DBG((" set nan BCN_INTERVAL = %#x\n", cmd_data->beacon_int));
|
ret = bcm_pack_xtlv_entry(&pxtlv, &end, WL_NAN_XTLV_BCN_INTERVAL,
|
sizeof(cmd_data->beacon_int), &cmd_data->beacon_int,
|
BCM_XTLV_OPTION_ALIGN32);
|
break;
|
case WL_NAN_XTLV_MAC_TXRATE:
|
default:
|
ret = -EINVAL;
|
break;
|
}
|
if (unlikely(ret)) {
|
WL_ERR((" unsupported attribute, attr = %s (%d) \n",
|
cmd_data->attr.name, cmd_data->attr.type));
|
goto fail;
|
}
|
|
nanioc->len = start - end;
|
nanioc_size = sizeof(wl_nan_ioc_t) + nanioc->len;
|
ret = wldev_iovar_setbuf(ndev, "nan", nanioc, nanioc_size,
|
cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan set config failed, error = %d \n", ret));
|
goto fail;
|
} else {
|
WL_DBG((" nan set config successful \n"));
|
}
|
|
fail:
|
if (nanioc) {
|
kfree(nanioc);
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_rtt_config_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
wl_nan_ranging_config_t rtt_config;
|
s32 ret = BCME_OK;
|
|
/* proceed only if mandatory argument is present - channel */
|
if (!cmd_data->chanspec) {
|
WL_ERR((" mandatory argument is not present \n"));
|
return -EINVAL;
|
}
|
|
/*
|
* command to test
|
*
|
* wl: wl proxd_nancfg 44/80 128 32 ff:ff:ff:ff:ff:ff 1
|
*
|
* wpa_cli: DRIVER NAN_RTT_CONFIG CHAN=44/80
|
*/
|
|
memset(&rtt_config, 0, sizeof(rtt_config));
|
rtt_config.chanspec = cmd_data->chanspec;
|
rtt_config.timeslot = 128;
|
rtt_config.duration = 32;
|
memcpy(&rtt_config.allow_mac, ðer_bcast, ETHER_ADDR_LEN);
|
rtt_config.flags = 1;
|
|
ret = wldev_iovar_setbuf(ndev, "proxd_nancfg", &rtt_config,
|
sizeof(wl_nan_ranging_config_t), cfg->ioctl_buf,
|
WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan rtt config failed, error = %d \n", ret));
|
} else {
|
WL_DBG((" nan rtt config successful \n"));
|
}
|
|
return ret;
|
}
|
|
int
|
wl_cfgnan_rtt_find_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
void *iovbuf;
|
wl_nan_ranging_list_t *rtt_list;
|
s32 iovbuf_size = NAN_RTT_IOVAR_BUF_SIZE;
|
s32 ret = BCME_OK;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
|
/*
|
* proceed only if mandatory arguments are present - channel, bitmap,
|
* mac address
|
*/
|
if ((!cmd_data->chanspec) || (!cmd_data->bmap) ||
|
ETHER_ISNULLADDR(&cmd_data->mac_addr.octet)) {
|
WL_ERR((" mandatory arguments are not present \n"));
|
return -EINVAL;
|
}
|
|
iovbuf = kzalloc(iovbuf_size, kflags);
|
if (!iovbuf) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
|
/*
|
* command to test
|
*
|
* wl: wl proxd_nanfind 1 44/80 <mac_addr> 0x300 5 6 1
|
*
|
* wpa_cli: DRIVER NAN_RTT_FIND MAC_ADDR=<mac_addr> CHAN=44/80 BMAP=0x300
|
*
|
*/
|
rtt_list = (wl_nan_ranging_list_t *)iovbuf;
|
rtt_list->count = 1;
|
rtt_list->num_peers_done = 0;
|
rtt_list->num_dws = 1;
|
rtt_list->rp[0].chanspec = cmd_data->chanspec;
|
memcpy(&rtt_list->rp[0].ea, &cmd_data->mac_addr,
|
sizeof(struct ether_addr));
|
rtt_list->rp[0].abitmap = cmd_data->bmap;
|
rtt_list->rp[0].frmcnt = 5;
|
rtt_list->rp[0].retrycnt = 6;
|
rtt_list->rp[0].flags = 1;
|
|
iovbuf_size = sizeof(wl_nan_ranging_list_t) +
|
sizeof(wl_nan_ranging_peer_t);
|
ret = wldev_iovar_setbuf(ndev, "proxd_nanfind", iovbuf,
|
iovbuf_size, cfg->ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
if (unlikely(ret)) {
|
WL_ERR((" nan rtt find failed, error = %d \n", ret));
|
} else {
|
WL_DBG((" nan rtt find successful \n"));
|
}
|
|
if (iovbuf) {
|
kfree(iovbuf);
|
}
|
|
return ret;
|
}
|
|
#ifdef WL_NAN_DEBUG
|
int
|
wl_cfgnan_debug_handler(struct net_device *ndev,
|
struct bcm_cfg80211 *cfg, char *cmd, int size, nan_cmd_data_t *cmd_data)
|
{
|
/*
|
* command to test
|
*
|
* wpa_cli: DRIVER NAN_DEBUG DEBUG=1
|
*
|
*/
|
|
g_nan_debug = cmd_data->debug_flag;
|
|
/* reconfigure nan events */
|
return wl_cfgnan_enable_events(ndev, cfg);
|
}
|
#endif /* WL_NAN_DEBUG */
|
|
static int wl_cfgnan_config_attr(char *buf, nan_config_attr_t *attr)
|
{
|
s32 ret = BCME_OK;
|
nan_config_attr_t *nanc = NULL;
|
|
/* only one attribute at a time */
|
for (nanc = &nan_config_attrs[0]; strlen(nanc->name) != 0; nanc++) {
|
if (!strncmp(nanc->name, buf, strlen(nanc->name))) {
|
strncpy((char *)attr->name, buf, strlen(nanc->name));
|
attr->type = nanc->type;
|
ret = strlen(nanc->name);
|
break;
|
}
|
}
|
|
return ret;
|
}
|
|
static int wl_cfgnan_parse_args(char *buf, nan_cmd_data_t *cmd_data)
|
{
|
s32 ret = BCME_OK;
|
char *token = buf;
|
char delim[] = " ";
|
|
while ((buf != NULL) && (token != NULL)) {
|
if (!strncmp(buf, PUB_ID_PREFIX, strlen(PUB_ID_PREFIX))) {
|
buf += strlen(PUB_ID_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->pub_id = simple_strtoul(token, NULL, 10);
|
cmd_data->local_id ? (cmd_data->remote_id = cmd_data->pub_id) :
|
(cmd_data->local_id = cmd_data->pub_id);
|
if (NAN_INVALID_ID(cmd_data->pub_id)) {
|
WL_ERR((" invalid publisher id, pub_id = %d \n",
|
cmd_data->pub_id));
|
ret = -EINVAL;
|
goto fail;
|
}
|
#ifdef NAN_P2P_CONFIG
|
} else if (!strncmp(buf, P2P_IE_PREFIX, strlen(P2P_IE_PREFIX))) {
|
buf += strlen(P2P_IE_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->p2p_info.data = token;
|
cmd_data->p2p_info.dlen = strlen(token);
|
} else if (!strncmp(buf, IE_EN_PREFIX, strlen(IE_EN_PREFIX))) {
|
buf += strlen(IE_EN_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->p2p_info.data = token;
|
cmd_data->p2p_info.dlen = strlen(token);
|
#endif /* NAN_P2P_CONFIG */
|
} else if (!strncmp(buf, SUB_ID_PREFIX, strlen(SUB_ID_PREFIX))) {
|
buf += strlen(SUB_ID_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->sub_id = simple_strtoul(token, NULL, 10);
|
cmd_data->local_id ? (cmd_data->remote_id = cmd_data->sub_id) :
|
(cmd_data->local_id = cmd_data->sub_id);
|
if (NAN_INVALID_ID(cmd_data->sub_id)) {
|
WL_ERR((" invalid subscriber id, sub_id = %d \n",
|
cmd_data->sub_id));
|
ret = -EINVAL;
|
goto fail;
|
}
|
} else if (!strncmp(buf, MAC_ADDR_PREFIX, strlen(MAC_ADDR_PREFIX))) {
|
buf += strlen(MAC_ADDR_PREFIX);
|
token = strsep(&buf, delim);
|
if (!wl_cfg80211_ether_atoe(token, &cmd_data->mac_addr)) {
|
WL_ERR((" invalid mac address, mac_addr = "MACDBG "\n",
|
MAC2STRDBG(cmd_data->mac_addr.octet)));
|
ret = -EINVAL;
|
goto fail;
|
}
|
} else if (!strncmp(buf, SVC_HASH_PREFIX, strlen(SVC_HASH_PREFIX))) {
|
buf += strlen(SVC_HASH_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->svc_hash.data = token;
|
cmd_data->svc_hash.dlen = WL_NAN_SVC_HASH_LEN;
|
} else if (!strncmp(buf, SVC_INFO_PREFIX, strlen(SVC_INFO_PREFIX))) {
|
buf += strlen(SVC_INFO_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->svc_info.data = token;
|
cmd_data->svc_info.dlen = strlen(token);
|
} else if (!strncmp(buf, CHAN_PREFIX, strlen(CHAN_PREFIX))) {
|
buf += strlen(CHAN_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->chanspec = wf_chspec_aton(token);
|
cmd_data->chanspec = wl_chspec_host_to_driver(cmd_data->chanspec);
|
if (NAN_INVALID_CHANSPEC(cmd_data->chanspec)) {
|
WL_ERR((" invalid chanspec, chanspec = 0x%04x \n",
|
cmd_data->chanspec));
|
ret = -EINVAL;
|
goto fail;
|
}
|
} else if (!strncmp(buf, BITMAP_PREFIX, strlen(BITMAP_PREFIX))) {
|
buf += strlen(BITMAP_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->bmap = simple_strtoul(token, NULL, 16);
|
} else if (!strncmp(buf, ATTR_PREFIX, strlen(ATTR_PREFIX))) {
|
buf += strlen(ATTR_PREFIX);
|
token = strsep(&buf, delim);
|
if (!wl_cfgnan_config_attr(token, &cmd_data->attr)) {
|
WL_ERR((" invalid attribute, attr = %s \n",
|
cmd_data->attr.name));
|
ret = -EINVAL;
|
goto fail;
|
}
|
} else if (!strncmp(buf, ROLE_PREFIX, strlen(ROLE_PREFIX))) {
|
buf += strlen(ROLE_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->role = simple_strtoul(token, NULL, 10);
|
if (NAN_INVALID_ROLE(cmd_data->role)) {
|
WL_ERR((" invalid role, role = %d \n", cmd_data->role));
|
ret = -EINVAL;
|
goto fail;
|
}
|
} else if (!strncmp(buf, MASTER_PREF_PREFIX,
|
strlen(MASTER_PREF_PREFIX))) {
|
buf += strlen(MASTER_PREF_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->master_pref = simple_strtoul(token, NULL, 10);
|
} else if (!strncmp(buf, CLUS_ID_PREFIX, strlen(CLUS_ID_PREFIX))) {
|
buf += strlen(CLUS_ID_PREFIX);
|
token = strsep(&buf, delim);
|
if (!wl_cfg80211_ether_atoe(token, &cmd_data->clus_id)) {
|
WL_ERR((" invalid cluster id, CLUS_ID = "MACDBG "\n",
|
MAC2STRDBG(cmd_data->clus_id.octet)));
|
ret = -EINVAL;
|
goto fail;
|
}
|
} else if (!strncmp(buf, IF_ADDR_PREFIX, strlen(IF_ADDR_PREFIX))) {
|
buf += strlen(IF_ADDR_PREFIX);
|
token = strsep(&buf, delim);
|
if (!wl_cfg80211_ether_atoe(token, &cmd_data->if_addr)) {
|
WL_ERR((" invalid cluster id, IF_ADDR = "MACDBG "\n",
|
MAC2STRDBG(cmd_data->if_addr.octet)));
|
ret = -EINVAL;
|
goto fail;
|
}
|
} else if (!strncmp(buf, BCN_INTERVAL_PREFIX,
|
strlen(BCN_INTERVAL_PREFIX))) {
|
buf += strlen(BCN_INTERVAL_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->beacon_int = simple_strtoul(token, NULL, 10);
|
} else if (!strncmp(buf, PUB_PR_PREFIX, strlen(PUB_PR_PREFIX))) {
|
buf += strlen(PUB_PR_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->pub_pr = simple_strtoul(token, NULL, 10);
|
} else if (!strncmp(buf, PUB_INT_PREFIX, strlen(PUB_INT_PREFIX))) {
|
buf += strlen(PUB_INT_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->pub_int = simple_strtoul(token, NULL, 10);
|
} else if (!strncmp(buf, DW_LEN_PREFIX, strlen(DW_LEN_PREFIX))) {
|
buf += strlen(DW_LEN_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->dw_len = simple_strtoul(token, NULL, 10);
|
} else if (!strncmp(buf, DEBUG_PREFIX, strlen(DEBUG_PREFIX))) {
|
buf += strlen(DEBUG_PREFIX);
|
token = strsep(&buf, delim);
|
cmd_data->debug_flag = simple_strtoul(token, NULL, 10);
|
} else if (!strncmp(buf, ACTIVE_OPTION, strlen(ACTIVE_OPTION))) {
|
buf += strlen(ACTIVE_OPTION);
|
token = strsep(&buf, delim);
|
cmd_data->flags |= WL_NAN_SUB_ACTIVE;
|
} else if (!strncmp(buf, SOLICITED_OPTION, strlen(SOLICITED_OPTION))) {
|
buf += strlen(SOLICITED_OPTION);
|
token = strsep(&buf, delim);
|
cmd_data->flags |= WL_NAN_PUB_SOLICIT;
|
} else if (!strncmp(buf, UNSOLICITED_OPTION, strlen(UNSOLICITED_OPTION))) {
|
buf += strlen(UNSOLICITED_OPTION);
|
token = strsep(&buf, delim);
|
cmd_data->flags |= WL_NAN_PUB_UNSOLICIT;
|
} else {
|
WL_ERR((" unknown token, token = %s, buf = %s \n", token, buf));
|
ret = -EINVAL;
|
goto fail;
|
}
|
}
|
|
fail:
|
return ret;
|
}
|
|
int
|
wl_cfgnan_cmd_handler(struct net_device *ndev, struct bcm_cfg80211 *cfg,
|
char *cmd, int cmd_len)
|
{
|
nan_cmd_data_t cmd_data;
|
u8 *buf = cmd;
|
u8 *cmd_name = NULL;
|
nan_cmd_t *nanc = NULL;
|
int buf_len = 0;
|
int ret = BCME_OK;
|
|
cmd_name = strsep((char **)&buf, " ");
|
if (buf) {
|
buf_len = strlen(buf);
|
}
|
|
WL_DBG((" cmd_name: %s, buf_len: %d, buf: %s \n", cmd_name, buf_len, buf));
|
|
memset(&cmd_data, 0, sizeof(cmd_data));
|
ret = wl_cfgnan_parse_args(buf, &cmd_data);
|
if (unlikely(ret)) {
|
WL_ERR((" argument parsing failed with error (%d), buf = %s \n",
|
ret, buf));
|
goto fail;
|
}
|
|
for (nanc = nan_cmds; nanc->name; nanc++) {
|
if (strncmp(nanc->name, cmd_name, strlen(nanc->name)) == 0) {
|
ret = (*nanc->func)(ndev, cfg, cmd, cmd_len, &cmd_data);
|
if (ret < BCME_OK) {
|
WL_ERR((" command (%s) failed with error (%d) \n",
|
cmd_name, ret));
|
}
|
}
|
}
|
|
fail:
|
return ret;
|
}
|
|
s32
|
wl_cfgnan_notify_proxd_status(struct bcm_cfg80211 *cfg,
|
bcm_struct_cfgdev *cfgdev, const wl_event_msg_t *event, void *data)
|
{
|
s32 ret = BCME_OK;
|
wl_nan_ranging_event_data_t *rdata;
|
s32 status;
|
u16 data_len;
|
s32 event_type;
|
s32 event_num;
|
u8 *buf = NULL;
|
u32 buf_len;
|
u8 *ptr, *end;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
s32 i;
|
|
if (!event || !data) {
|
WL_ERR((" event data is NULL \n"));
|
return -EINVAL;
|
}
|
|
status = ntoh32(event->reason);
|
event_type = ntoh32(event->event_type);
|
event_num = ntoh32(event->reason);
|
data_len = ntoh32(event->datalen);
|
|
WL_DBG((" proxd event: type: %d num: %d len: %d \n",
|
event_type, event_num, data_len));
|
|
if (NAN_INVALID_PROXD_EVENT(event_num)) {
|
WL_ERR((" unsupported event, num: %d \n", event_num));
|
return -EINVAL;
|
}
|
|
#ifdef WL_NAN_DEBUG
|
if (g_nan_debug) {
|
WL_DBG((" event name: WLC_E_PROXD_NAN_EVENT \n"));
|
WL_DBG((" event data: \n"));
|
prhex(NULL, data, data_len);
|
}
|
#endif /* WL_NAN_DEBUG */
|
|
if (data_len < sizeof(wl_nan_ranging_event_data_t)) {
|
WL_ERR((" wrong data len \n"));
|
return -EINVAL;
|
}
|
|
rdata = (wl_nan_ranging_event_data_t *)data;
|
|
WL_DBG((" proxd event: count:%d success_count:%d mode:%d \n",
|
rdata->count, rdata->success_count, rdata->mode));
|
|
#ifdef WL_NAN_DEBUG
|
if (g_nan_debug) {
|
prhex(" event data: ", data, data_len);
|
}
|
#endif /* WL_NAN_DEBUG */
|
|
buf_len = NAN_IOCTL_BUF_SIZE;
|
buf = kzalloc(buf_len, kflags);
|
if (!buf) {
|
WL_ERR((" memory allocation failed \n"));
|
return -ENOMEM;
|
}
|
end = buf + buf_len;
|
|
for (i = 0; i < rdata->count; i++) {
|
if (&rdata->rr[i] == NULL) {
|
ret = -EINVAL;
|
goto fail;
|
}
|
|
ptr = buf;
|
WL_DBG((" ranging data for mac:"MACDBG" \n",
|
MAC2STRDBG(rdata->rr[i].ea.octet)));
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s " MAC_ADDR_PREFIX MACF
|
" "STATUS_PREFIX"%s", EVENT_RTT_STATUS_STR,
|
ETHER_TO_MACF(rdata->rr[i].ea), (rdata->rr[i].status == 1) ?
|
"success" : "fail");
|
|
if (rdata->rr[i].status == 1) {
|
/* add tsf and distance only if status is success */
|
ptr += snprintf(ptr, end-ptr, " "TIMESTAMP_PREFIX"0x%x "
|
DISTANCE_PREFIX"%d.%04d", rdata->rr[i].timestamp,
|
rdata->rr[i].distance >> 4,
|
((rdata->rr[i].distance & 0x0f) * 625));
|
}
|
if (ptr > end) {
|
WL_ERR(("Buffer overflow. userspace string truncated: %s, len: %zu\n",
|
buf, strlen(buf)));
|
}
|
|
}
|
|
fail:
|
if (buf) {
|
kfree(buf);
|
}
|
|
return ret;
|
}
|
|
s32
|
wl_cfgnan_notify_nan_status(struct bcm_cfg80211 *cfg,
|
bcm_struct_cfgdev *cfgdev, const wl_event_msg_t *event, void *data)
|
{
|
s32 ret = BCME_OK;
|
u16 data_len;
|
u32 event_num;
|
s32 event_type;
|
nan_event_hdr_t nan_hdr;
|
wl_nan_tlv_data_t tlv_data;
|
u8 *buf = NULL;
|
u32 buf_len;
|
u8 *ptr, *end;
|
u16 kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
|
if (!event || !data) {
|
WL_ERR((" event data is NULL \n"));
|
return -EINVAL;
|
}
|
|
event_type = ntoh32(event->event_type);
|
event_num = ntoh32(event->reason);
|
data_len = ntoh32(event->datalen);
|
memset(&nan_hdr, 0, sizeof(nan_event_hdr_t));
|
nan_hdr.event_subtype = event_num;
|
|
WL_DBG((" nan event: type: %d num: %d len: %d \n",
|
event_type, event_num, data_len));
|
|
if (NAN_INVALID_EVENT(event_num)) {
|
WL_ERR((" unsupported event, num: %d \n", event_num));
|
return -EINVAL;
|
}
|
|
#ifdef WL_NAN_DEBUG
|
if (g_nan_debug) {
|
print_event_name(event_num);
|
WL_DBG((" event data: \n"));
|
prhex(NULL, data, data_len);
|
}
|
#endif /* WL_NAN_DEBUG */
|
|
/* unpack the tlvs */
|
memset(&tlv_data, 0, sizeof(wl_nan_tlv_data_t));
|
bcm_unpack_xtlv_buf(&tlv_data, data, data_len,
|
BCM_XTLV_OPTION_ALIGN32, wl_cfgnan_set_vars_cbfn);
|
|
/*
|
* send as preformatted hex string
|
*
|
* EVENT_NAN <event_type> <tlv_hex_string>
|
*/
|
|
buf_len = NAN_IOCTL_BUF_SIZE;
|
buf = ptr = kzalloc(buf_len, kflags);
|
if (!buf) {
|
WL_ERR((" memory allocation failed \n"));
|
ret = -ENOMEM;
|
goto fail;
|
}
|
end = buf + buf_len;
|
|
switch (event_num) {
|
case WL_NAN_EVENT_START:
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s " CLUS_ID_PREFIX MACF,
|
NAN_EVENT_STR_STARTED, ETHER_TO_MACF(tlv_data.nstatus.cid));
|
break;
|
case WL_NAN_EVENT_JOIN:
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s " CLUS_ID_PREFIX MACF,
|
NAN_EVENT_STR_JOINED, ETHER_TO_MACF(tlv_data.nstatus.cid));
|
break;
|
case WL_NAN_EVENT_STOP:
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s " CLUS_ID_PREFIX MACF,
|
NAN_EVENT_STR_STOPPED, ETHER_TO_MACF(tlv_data.nstatus.cid));
|
break;
|
case WL_NAN_EVENT_ROLE:
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s "ROLE_PREFIX "%d "
|
CLUS_ID_PREFIX MACF, NAN_EVENT_STR_ROLE_CHANGE,
|
tlv_data.nstatus.role, ETHER_TO_MACF(tlv_data.nstatus.cid));
|
break;
|
case WL_NAN_EVENT_DISCOVERY_RESULT:
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s " PUB_ID_PREFIX"%d "
|
SUB_ID_PREFIX"%d " MAC_ADDR_PREFIX MACF,
|
NAN_EVENT_STR_SDF_RX, tlv_data.pub_id, tlv_data.sub_id,
|
ETHER_TO_MACF(tlv_data.mac_addr));
|
if (tlv_data.svc_info.data && tlv_data.svc_info.dlen) {
|
WL_DBG((" service info present \n"));
|
if ((strlen(ptr) + tlv_data.svc_info.dlen) >= buf_len) {
|
WL_ERR((" service info length = %d\n",
|
tlv_data.svc_info.dlen));
|
WL_ERR((" insufficent buffer to copy service info \n"));
|
ret = -EOVERFLOW;
|
goto fail;
|
}
|
ptr += snprintf(ptr, end-ptr, " %s", SVC_INFO_PREFIX);
|
ptr += bcm_format_hex(ptr, tlv_data.svc_info.data,
|
tlv_data.svc_info.dlen);
|
} else {
|
WL_DBG((" service info not present \n"));
|
}
|
|
if (tlv_data.vend_info.data && tlv_data.vend_info.dlen) {
|
struct ether_addr *ea;
|
u8 *temp_data = tlv_data.vend_info.data;
|
uint32 bitmap;
|
u16 dlen = tlv_data.vend_info.dlen;
|
chanspec_t chanspec;
|
uint8 mapcontrol;
|
uint8 proto;
|
|
WL_DBG((" vendor info present \n"));
|
if ((*temp_data != NAN_ATTR_VENDOR_SPECIFIC) ||
|
(dlen < NAN_VENDOR_HDR_SIZE)) {
|
WL_ERR((" error in vendor info attribute \n"));
|
ret = -EINVAL;
|
goto fail;
|
} else {
|
WL_DBG((" vendor info not present \n"));
|
}
|
|
if (*(temp_data + 6) == NAN_VENDOR_TYPE_RTT) {
|
temp_data += NAN_VENDOR_HDR_SIZE;
|
ea = (struct ether_addr *)temp_data;
|
temp_data += ETHER_ADDR_LEN;
|
mapcontrol = *temp_data++;
|
proto = *temp_data++;
|
bitmap = *(uint32 *)temp_data;
|
temp_data += 4;
|
chanspec = *(chanspec_t *)temp_data;
|
ptr += snprintf(ptr, end-ptr,
|
" "BITMAP_PREFIX"0x%x "CHAN_PREFIX"%d/%s",
|
bitmap, wf_chspec_ctlchan(chanspec),
|
wf_chspec_to_bw_str(chanspec));
|
WL_DBG((" bitmap: 0x%x channel: %d bandwidth: %s \n", bitmap,
|
wf_chspec_ctlchan(chanspec),
|
wf_chspec_to_bw_str(chanspec)));
|
}
|
}
|
break;
|
case WL_NAN_EVENT_REPLIED:
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s " PUB_ID_PREFIX"%d "
|
MAC_ADDR_PREFIX MACF, NAN_EVENT_STR_REPLIED,
|
tlv_data.pub_id, ETHER_TO_MACF(tlv_data.mac_addr));
|
break;
|
case WL_NAN_EVENT_TERMINATED:
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s " PUB_ID_PREFIX"%d ",
|
NAN_EVENT_STR_TERMINATED, tlv_data.pub_id);
|
break;
|
case WL_NAN_EVENT_RECEIVE:
|
ptr += snprintf(ptr, end-ptr,
|
SUPP_EVENT_PREFIX"%s " INSTANCE_ID_PREFIX"%d "
|
REMOTE_INSTANCE_ID_PREFIX"%d " MAC_ADDR_PREFIX MACF,
|
NAN_EVENT_STR_FOLLOWUP_RX, tlv_data.inst_id,
|
tlv_data.peer_inst_id, ETHER_TO_MACF(tlv_data.mac_addr));
|
if (tlv_data.svc_info.data && tlv_data.svc_info.dlen) {
|
WL_DBG((" service info present \n"));
|
if ((strlen(ptr) + tlv_data.svc_info.dlen) >= buf_len) {
|
WL_ERR((" service info length = %d\n",
|
tlv_data.svc_info.dlen));
|
WL_ERR((" insufficent buffer to copy service info \n"));
|
ret = -EOVERFLOW;
|
goto fail;
|
}
|
ptr += snprintf(ptr, end-ptr, " %s", SVC_INFO_PREFIX);
|
ptr += bcm_format_hex(ptr, tlv_data.svc_info.data,
|
tlv_data.svc_info.dlen);
|
} else {
|
WL_DBG((" service info not present \n"));
|
}
|
break;
|
case WL_NAN_EVENT_SCAN_COMPLETE:
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s " CLUS_ID_PREFIX MACF,
|
NAN_EVENT_STR_SCAN_COMPLETE, ETHER_TO_MACF(tlv_data.nstatus.cid));
|
break;
|
case WL_NAN_EVENT_STATUS_CHG:
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s " CLUS_ID_PREFIX MACF,
|
NAN_EVENT_STR_STATUS_CHANGE, ETHER_TO_MACF(tlv_data.nstatus.cid));
|
break;
|
case WL_NAN_EVENT_MERGE:
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s " CLUS_ID_PREFIX MACF,
|
NAN_EVENT_STR_MERGED, ETHER_TO_MACF(tlv_data.nstatus.cid));
|
break;
|
#ifdef NAN_P2P_CONFIG
|
case WL_NAN_EVENT_P2P:
|
ptr += snprintf(ptr, end-ptr, SUPP_EVENT_PREFIX"%s "
|
MAC_ADDR_PREFIX MACF, NAN_EVENT_STR_P2P_RX,
|
ETHER_TO_MACF(tlv_data.mac_addr));
|
if (tlv_data.vend_info.data && tlv_data.vend_info.dlen) {
|
u8 *data = tlv_data.vend_info.data;
|
u16 dlen = tlv_data.vend_info.dlen;
|
|
WL_DBG((" vendor info present %d dlen = %d\n",
|
*(data + 6), (dlen - (NAN_VENDOR_HDR_SIZE+1))));
|
if ((*data != NAN_ATTR_VENDOR_SPECIFIC) ||
|
(dlen < NAN_VENDOR_HDR_SIZE)) {
|
WL_ERR((" error in vendor info attribute \n"));
|
ret = -EINVAL;
|
goto fail;
|
} else {
|
WL_DBG((" vendor info present \n"));
|
}
|
|
if (*(data + 6) == NAN_VENDOR_TYPE_P2P) {
|
data += NAN_VENDOR_HDR_SIZE;
|
ptr += snprintf(ptr, end-ptr, " %s", P2P_IE_PREFIX);
|
ptr += bcm_format_hex(ptr, data, (dlen - (NAN_VENDOR_HDR_SIZE)));
|
}
|
}
|
break;
|
#endif /* NAN_P2P_CONFIG */
|
default:
|
WL_ERR((" unknown event \n"));
|
break;
|
}
|
if (ptr > end) {
|
WL_ERR(("Buffer overflow. userspace string truncated: %s, len: %zu\n",
|
buf, strlen(buf)));
|
}
|
|
|
fail:
|
if (buf) {
|
kfree(buf);
|
}
|
if (tlv_data.svc_info.data) {
|
kfree(tlv_data.svc_info.data);
|
tlv_data.svc_info.data = NULL;
|
tlv_data.svc_info.dlen = 0;
|
}
|
if (tlv_data.vend_info.data) {
|
kfree(tlv_data.vend_info.data);
|
tlv_data.vend_info.data = NULL;
|
tlv_data.vend_info.dlen = 0;
|
}
|
|
return ret;
|
}
|
