/*
|
* Bigdata logging and report. None EWP and Hang event.
|
*
|
* Copyright (C) 2020, Broadcom.
|
*
|
* 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.
|
*
|
*
|
* <<Broadcom-WL-IPTag/Dual:>>
|
*/
|
#include <typedefs.h>
|
#include <osl.h>
|
#include <dngl_stats.h>
|
#include <bcmutils.h>
|
#include <dhd.h>
|
#include <dhd_dbg.h>
|
#include <wl_cfg80211.h>
|
#include <wldev_common.h>
|
#include <bcmendian.h>
|
#include <wlioctl.h>
|
#include <dhd_linux_wq.h>
|
#include <wl_bigdata.h>
|
|
#define WL_AP_BIGDATA_LOG(args) WL_DBG(args)
|
|
#define WLC_E_IS_ASSOC(e, r) \
|
(((e == WLC_E_ASSOC_IND) || (e == WLC_E_REASSOC_IND)) && r == DOT11_SC_SUCCESS)
|
#define WLC_E_IS_DEAUTH(e) \
|
(e == WLC_E_DISASSOC_IND || e == WLC_E_DEAUTH_IND || e == WLC_E_DEAUTH)
|
|
static void dump_ap_stadata(wl_ap_sta_data_t *ap_sta_data);
|
static inline void copy_ap_stadata(wl_ap_sta_data_t *dest, wl_ap_sta_data_t *src);
|
static void wg_rate_dot11mode(uint32 *rate, uint8 *channel, uint32 *mode_80211);
|
static void wg_ht_mimo_ant(uint32 *nss, wl_rateset_args_t *rateset);
|
static void wg_vht_mimo_ant(uint32 *nss, wl_rateset_args_t *rateset);
|
#if defined(WL11AX)
|
static void wg_he_mimo_ant(uint32 *nss, uint16 *mcsset);
|
#endif /* WL11AX */
|
static int wg_parse_ap_stadata(struct net_device *dev, struct ether_addr *sta_mac,
|
wl_ap_sta_data_t *ap_sta_data);
|
|
static void
|
dump_ap_stadata(wl_ap_sta_data_t *ap_sta_data)
|
{
|
int i;
|
|
if (!ap_sta_data) {
|
WL_AP_BIGDATA_LOG(("ap_sta_data is NULL\n"));
|
return;
|
}
|
|
for (i = 0; i < MAX_STA_INFO_AP_CNT; i++) {
|
if (!ap_sta_data[i].is_empty) {
|
WL_AP_BIGDATA_LOG(("idx %d "MACDBG" dis %d empty %d\n",
|
i, MAC2STRDBG((char *)&ap_sta_data[i].mac),
|
ap_sta_data[i].disconnected, ap_sta_data[i].is_empty));
|
WL_AP_BIGDATA_LOG(("mode %d nss %d chanspec %d rssi %d "
|
"rate %d reason_code %d\n\n",
|
ap_sta_data[i].mode_80211,
|
ap_sta_data[i].nss, ap_sta_data[i].chanspec,
|
ap_sta_data[i].rssi, ap_sta_data[i].rate,
|
ap_sta_data[i].reason_code));
|
}
|
}
|
}
|
|
static inline void
|
copy_ap_stadata(wl_ap_sta_data_t *dest, wl_ap_sta_data_t *src)
|
{
|
memcpy(dest, src, sizeof(wl_ap_sta_data_t));
|
dest->is_empty = FALSE;
|
dest->disconnected = FALSE;
|
dest->reason_code = 0;
|
}
|
|
static void
|
get_copy_ptr_stadata(struct ether_addr *sta_mac, wl_ap_sta_data_t *sta_data,
|
uint32 *sta_list_cnt, void **data)
|
{
|
int i;
|
int discon_idx = -1;
|
int empty_idx = -1;
|
|
if (!sta_mac || !sta_data || !sta_list_cnt ||!data) {
|
WL_ERR(("sta_mac=%p sta_data=%p sta_lit_cnt=%p data=%p\n",
|
sta_mac, sta_data, sta_list_cnt, data));
|
return;
|
}
|
|
/* Find already existed sta */
|
for (i = 0; i < MAX_STA_INFO_AP_CNT; i++) {
|
if (!memcmp((char*)sta_mac, (char*)&sta_data[i].mac, ETHER_ADDR_LEN)) {
|
WL_AP_BIGDATA_LOG(("found existed "
|
"STA idx %d "MACDBG"\n",
|
i, MAC2STRDBG((char *)sta_mac)));
|
*data = (wl_ap_sta_data_t *)&sta_data[i];
|
return;
|
}
|
|
if (sta_data[i].disconnected && (discon_idx == -1)) {
|
discon_idx = i;
|
}
|
|
if (sta_data[i].is_empty && (empty_idx == -1)) {
|
empty_idx = i;
|
}
|
}
|
|
/* Buf is max */
|
if (*sta_list_cnt >= MAX_STA_INFO_AP_CNT) {
|
if (discon_idx != -1) {
|
WL_AP_BIGDATA_LOG(("delete disconnected "
|
"idx %d "MACDBG"\n",
|
discon_idx, MAC2STRDBG((char *)sta_mac)));
|
*data = (wl_ap_sta_data_t *)&sta_data[discon_idx];
|
return;
|
}
|
}
|
|
/* Buf is not max */
|
if (empty_idx != -1) {
|
(*sta_list_cnt)++;
|
WL_AP_BIGDATA_LOG(("empty idx %d \n", empty_idx));
|
*data = (wl_ap_sta_data_t *)&sta_data[empty_idx];
|
return;
|
}
|
}
|
|
static void
|
wg_rate_dot11mode(uint32 *rate, uint8 *channel, uint32 *mode_80211)
|
{
|
if (*rate <= DOT11_11B_MAX_RATE) {
|
/* 11b maximum rate is 11Mbps. 11b mode */
|
*mode_80211 = BIGDATA_DOT11_11B_MODE;
|
} else {
|
/* It's not HT Capable case. */
|
if (*channel > DOT11_2GHZ_MAX_CH_NUM) {
|
*mode_80211 = BIGDATA_DOT11_11A_MODE; /* 11a mode */
|
} else {
|
*mode_80211 = BIGDATA_DOT11_11G_MODE; /* 11g mode */
|
}
|
}
|
}
|
|
static void
|
wg_ht_mimo_ant(uint32 *nss, wl_rateset_args_t *rateset)
|
{
|
int i;
|
|
*nss = 0;
|
for (i = 0; i < MAX_STREAMS_SUPPORTED; i++) {
|
int8 bitmap = DOT11_HT_MCS_RATE_MASK;
|
if (i == MAX_STREAMS_SUPPORTED-1) {
|
bitmap = DOT11_RATE_MASK;
|
}
|
if (rateset->mcs[i] & bitmap) {
|
(*nss)++;
|
}
|
}
|
}
|
|
static void
|
wg_vht_mimo_ant(uint32 *nss, wl_rateset_args_t *rateset)
|
{
|
int i;
|
uint32 mcs_code;
|
|
*nss = 0;
|
|
for (i = 1; i <= VHT_CAP_MCS_MAP_NSS_MAX; i++) {
|
mcs_code = VHT_MCS_MAP_TO_MCS_CODE(rateset->vht_mcs[i - 1]);
|
if (mcs_code != VHT_CAP_MCS_MAP_NONE) {
|
(*nss)++;
|
}
|
}
|
}
|
|
#if defined(WL11AX)
|
static void
|
wg_he_mimo_ant(uint32 *nss, uint16 *mcsset)
|
{
|
int i;
|
|
*nss = 0;
|
|
for (i = 0; i <= HE_MCS_MAP_NSS_MAX; i++) {
|
if (mcsset[i]) {
|
(*nss)++;
|
}
|
}
|
}
|
#endif /* WL11AX */
|
|
static int
|
wg_parse_ap_stadata(struct net_device *dev, struct ether_addr *sta_mac,
|
wl_ap_sta_data_t *ap_sta_data)
|
{
|
sta_info_v4_t *sta_v4 = NULL;
|
sta_info_v5_t *sta_v5 = NULL;
|
wl_rateset_args_t *rateset_adv;
|
int ret = BCME_OK;
|
char* ioctl_buf = NULL;
|
#if defined(WL11AX)
|
struct wl_rateset_args_v2 *rateset_adv_v2;
|
#endif
|
|
ioctl_buf = (char*)kmalloc(WLC_IOCTL_MEDLEN, GFP_KERNEL);
|
if (ioctl_buf == NULL) {
|
WL_ERR(("failed to allocated ioctl_buf \n"));
|
return BCME_ERROR;
|
}
|
|
ret = wldev_iovar_getbuf(dev, "sta_info", (struct ether_addr *)sta_mac,
|
ETHER_ADDR_LEN, ioctl_buf, WLC_IOCTL_MEDLEN, NULL);
|
|
if (ret < 0) {
|
WL_ERR(("sta_info err value :%d\n", ret));
|
ret = BCME_ERROR;
|
goto done;
|
}
|
|
sta_v4 = (sta_info_v4_t *)ioctl_buf;
|
ap_sta_data->mac = *sta_mac;
|
ap_sta_data->rssi = 0;
|
ap_sta_data->mimo = 0;
|
|
rateset_adv = &sta_v4->rateset_adv;
|
ap_sta_data->chanspec = sta_v4->chanspec;
|
|
WL_AP_BIGDATA_LOG(("sta_info ver %d\n", sta_v4->ver));
|
|
if (sta_v4->ver == WL_STA_VER_5) {
|
sta_v5 = (sta_info_v5_t *)ioctl_buf;
|
ap_sta_data->chanspec = sta_v5->chanspec;
|
rateset_adv = &sta_v5->rateset_adv;
|
}
|
|
ap_sta_data->channel = wf_chspec_ctlchan(ap_sta_data->chanspec);
|
ap_sta_data->rate =
|
(sta_v4->rateset.rates[sta_v4->rateset.count - 1] & DOT11_RATE_MASK) / 2;
|
|
if (sta_v4->vht_flags) {
|
ap_sta_data->mode_80211 = BIGDATA_DOT11_11AC_MODE;
|
wg_vht_mimo_ant(&ap_sta_data->nss, rateset_adv);
|
} else if (sta_v4->ht_capabilities) {
|
ap_sta_data->mode_80211 = BIGDATA_DOT11_11N_MODE;
|
wg_ht_mimo_ant(&ap_sta_data->nss, rateset_adv);
|
} else {
|
wg_rate_dot11mode(&ap_sta_data->rate, &ap_sta_data->channel,
|
&ap_sta_data->mode_80211);
|
}
|
|
#if defined(WL11AX)
|
ret = wldev_iovar_getbuf(dev, "rateset", NULL, 0, ioctl_buf,
|
sizeof(wl_rateset_args_v2_t), NULL);
|
if (ret < 0) {
|
WL_ERR(("get rateset failed = %d\n", ret));
|
} else {
|
rateset_adv_v2 = (wl_rateset_args_v2_t *)ioctl_buf;
|
WL_AP_BIGDATA_LOG(("rateset ver %d\n", rateset_adv_v2->version));
|
|
if (rateset_adv_v2->version == RATESET_ARGS_V2) {
|
rateset_adv_v2 = (wl_rateset_args_v2_t *)&sta_v4->rateset_adv;
|
if (sta_v4->ver == WL_STA_VER_5) {
|
rateset_adv_v2 = (wl_rateset_args_v2_t *)&sta_v5->rateset_adv;
|
}
|
|
if (rateset_adv_v2->he_mcs[0]) {
|
WL_AP_BIGDATA_LOG(("there is he mcs rate\n"));
|
ap_sta_data->mode_80211 = BIGDATA_DOT11_11AX_MODE;
|
wg_he_mimo_ant(&ap_sta_data->nss, &rateset_adv_v2->he_mcs[0]);
|
}
|
}
|
}
|
#endif /* WL11AX */
|
|
if (ap_sta_data->nss) {
|
ap_sta_data->nss = ap_sta_data->nss - 1;
|
}
|
|
done:
|
if (ioctl_buf) {
|
kfree(ioctl_buf);
|
}
|
|
return ret;
|
}
|
|
void
|
wl_gather_ap_stadata(void *handle, void *event_info, u8 event)
|
{
|
u32 event_type = 0;
|
u32 reason = 0;
|
u32 status = 0;
|
struct ether_addr sta_mac;
|
dhd_pub_t *dhdp;
|
|
struct net_device *dev = NULL;
|
struct bcm_cfg80211 *cfg = NULL;
|
wl_event_msg_t *e;
|
|
wl_ap_sta_data_t *sta_data;
|
wl_ap_sta_data_t temp_sta_data;
|
void *data = NULL;
|
int i;
|
int ret;
|
|
ap_sta_wq_data_t *wq_event_data = event_info;
|
if (!wq_event_data) {
|
WL_ERR(("wq_event_data is NULL\n"));
|
return;
|
}
|
|
cfg = (struct bcm_cfg80211 *)wq_event_data->bcm_cfg;
|
if (!cfg || !cfg->ap_sta_info) {
|
WL_ERR(("cfg=%p ap_sta_info=%p\n", cfg, (cfg ? cfg->ap_sta_info : NULL)));
|
if (wq_event_data) {
|
kfree(wq_event_data);
|
}
|
return;
|
}
|
|
mutex_lock(&cfg->ap_sta_info->wq_data_sync);
|
|
dhdp = (dhd_pub_t *)cfg->pub;
|
e = &wq_event_data->e;
|
dev = (struct net_device *)wq_event_data->ndev;
|
|
if (!e || !dev) {
|
WL_ERR(("e=%p dev=%p\n", e, dev));
|
goto done;
|
}
|
|
if (!wl_get_drv_status(cfg, AP_CREATED, dev)) {
|
WL_ERR(("skip to gather data becasue interface is not available\n"));
|
goto done;
|
}
|
|
sta_data = cfg->ap_sta_info->ap_sta_data;
|
|
event_type = ntoh32(e->event_type);
|
reason = ntoh32(e->reason);
|
status = ntoh32(e->status);
|
sta_mac = e->addr;
|
|
if (!sta_data) {
|
WL_ERR(("sta_data is NULL\n"));
|
goto done;
|
}
|
|
WL_AP_BIGDATA_LOG((""MACDBG" event %d status %d reason %d\n",
|
MAC2STRDBG((char*)&sta_mac), event_type, status, reason));
|
|
if (WLC_E_IS_ASSOC(event_type, reason)) {
|
ret = wg_parse_ap_stadata(dev, &sta_mac, &temp_sta_data);
|
if (ret < 0) {
|
WL_AP_BIGDATA_LOG(("sta_info err value :%d\n", ret));
|
goto done;
|
}
|
|
if (cfg->ap_sta_info->sta_list_cnt == 0) {
|
copy_ap_stadata(&sta_data[0], &temp_sta_data);
|
cfg->ap_sta_info->sta_list_cnt++;
|
dump_ap_stadata(sta_data);
|
} else {
|
get_copy_ptr_stadata(&sta_mac, sta_data,
|
&cfg->ap_sta_info->sta_list_cnt, &data);
|
if (data != NULL) {
|
copy_ap_stadata((wl_ap_sta_data_t *)data, &temp_sta_data);
|
dump_ap_stadata(sta_data);
|
}
|
}
|
}
|
|
if (WLC_E_IS_DEAUTH(event_type)) {
|
/* Find already existed sta */
|
for (i = 0; i < MAX_STA_INFO_AP_CNT; i++) {
|
if (!sta_data[i].is_empty &&
|
!memcmp((char*)&sta_mac, (char*)&sta_data[i].mac, ETHER_ADDR_LEN)) {
|
WL_AP_BIGDATA_LOG(("found disconnected "
|
"STA idx %d "MACDBG"\n",
|
i, MAC2STRDBG((char *)&sta_mac)));
|
sta_data[i].is_empty = FALSE;
|
sta_data[i].disconnected = TRUE;
|
sta_data[i].reason_code = reason;
|
dump_ap_stadata(sta_data);
|
goto done;
|
}
|
}
|
}
|
|
done:
|
if (wq_event_data) {
|
ASSERT(dhdp->osh);
|
MFREE(dhdp->osh, wq_event_data, sizeof(ap_sta_wq_data_t));
|
}
|
mutex_unlock(&cfg->ap_sta_info->wq_data_sync);
|
}
|
|
int
|
wl_attach_ap_stainfo(void *bcm_cfg)
|
{
|
gfp_t kflags;
|
uint32 alloc_len;
|
wl_ap_sta_info_t *sta_info;
|
wl_ap_sta_data_t *sta_data = NULL;
|
int i;
|
struct bcm_cfg80211 *cfg = (struct bcm_cfg80211 *)bcm_cfg;
|
|
if (!cfg) {
|
WL_ERR(("cfg is NULL\n"));
|
return -EINVAL;
|
}
|
|
kflags = in_atomic() ? GFP_ATOMIC : GFP_KERNEL;
|
|
alloc_len = sizeof(wl_ap_sta_info_t);
|
sta_info = (wl_ap_sta_info_t *)kzalloc(alloc_len, kflags);
|
|
if (unlikely(!sta_info)) {
|
WL_ERR(("could not allocate memory for - "
|
"wl_ap_sta_info_t\n"));
|
goto fail;
|
}
|
cfg->ap_sta_info = sta_info;
|
|
alloc_len = sizeof(wl_ap_sta_data_t) * MAX_STA_INFO_AP_CNT;
|
sta_data = (wl_ap_sta_data_t *)kzalloc(alloc_len, kflags);
|
|
if (unlikely(!sta_data)) {
|
WL_ERR(("could not allocate memory for - "
|
"wl_ap_sta_data_t\n"));
|
goto fail;
|
}
|
|
cfg->ap_sta_info->sta_list_cnt = 0;
|
|
for (i = 0; i < MAX_STA_INFO_AP_CNT; i++) {
|
sta_data[i].is_empty = TRUE;
|
memset(&sta_data[i].mac, 0, ETHER_ADDR_LEN);
|
}
|
|
cfg->ap_sta_info->ap_sta_data = sta_data;
|
|
mutex_init(&cfg->ap_sta_info->wq_data_sync);
|
|
WL_ERR(("attach success\n"));
|
|
return BCME_OK;
|
|
fail:
|
if (sta_data) {
|
kfree(sta_data);
|
cfg->ap_sta_info->ap_sta_data = NULL;
|
}
|
|
if (sta_info) {
|
kfree(sta_info);
|
cfg->ap_sta_info = NULL;
|
}
|
|
return BCME_ERROR;
|
}
|
|
int
|
wl_detach_ap_stainfo(void *bcm_cfg)
|
{
|
struct bcm_cfg80211 *cfg = (struct bcm_cfg80211 *)bcm_cfg;
|
|
if (!cfg || !cfg->ap_sta_info) {
|
WL_ERR(("cfg=%p ap_sta_info=%p\n",
|
cfg, (cfg ? cfg->ap_sta_info : NULL)));
|
return -EINVAL;
|
}
|
|
if (cfg->ap_sta_info->ap_sta_data) {
|
kfree(cfg->ap_sta_info->ap_sta_data);
|
cfg->ap_sta_info->ap_sta_data = NULL;
|
}
|
|
mutex_destroy(&cfg->ap_sta_info->wq_data_sync);
|
|
kfree(cfg->ap_sta_info);
|
cfg->ap_sta_info = NULL;
|
|
WL_ERR(("detach success\n"));
|
|
return BCME_OK;
|
}
|
|
int
|
wl_ap_stainfo_init(void *bcm_cfg)
|
{
|
int i;
|
wl_ap_sta_data_t *sta_data;
|
struct bcm_cfg80211 *cfg = (struct bcm_cfg80211 *)bcm_cfg;
|
|
if (!cfg || !cfg->ap_sta_info) {
|
WL_ERR(("cfg=%p ap_sta_info=%p\n",
|
cfg, (cfg ? cfg->ap_sta_info : NULL)));
|
return -EINVAL;
|
}
|
|
sta_data = cfg->ap_sta_info->ap_sta_data;
|
cfg->ap_sta_info->sta_list_cnt = 0;
|
|
if (!sta_data) {
|
WL_ERR(("ap_sta_data is NULL\n"));
|
return -EINVAL;
|
}
|
|
for (i = 0; i < MAX_STA_INFO_AP_CNT; i++) {
|
sta_data[i].is_empty = TRUE;
|
memset(&sta_data[i].mac, 0, ETHER_ADDR_LEN);
|
}
|
|
return BCME_OK;
|
}
|
|
int
|
wl_get_ap_stadata(void *bcm_cfg, struct ether_addr *sta_mac, void **data)
|
{
|
int i;
|
wl_ap_sta_data_t *sta_data;
|
struct bcm_cfg80211 *cfg = (struct bcm_cfg80211 *)bcm_cfg;
|
|
if (!cfg || !cfg->ap_sta_info) {
|
WL_ERR(("cfg=%p ap_sta_info=%p\n",
|
cfg, (cfg ? cfg->ap_sta_info : NULL)));
|
return -EINVAL;
|
}
|
|
if (!sta_mac || !data) {
|
WL_ERR(("sta_mac=%p data=%p\n", sta_mac, data));
|
return -EINVAL;
|
}
|
|
sta_data = cfg->ap_sta_info->ap_sta_data;
|
|
if (!sta_data) {
|
WL_ERR(("ap_sta_data is NULL\n"));
|
return -EINVAL;
|
}
|
|
/* Find already existed sta */
|
for (i = 0; i < MAX_STA_INFO_AP_CNT; i++) {
|
if (!sta_data[i].is_empty) {
|
WL_AP_BIGDATA_LOG(("%d " MACDBG " " MACDBG "\n", i,
|
MAC2STRDBG((char *)sta_mac),
|
MAC2STRDBG((char*)&sta_data[i].mac)));
|
|
if (!memcmp(sta_mac, (char*)&sta_data[i].mac, ETHER_ADDR_LEN)) {
|
WL_AP_BIGDATA_LOG(("Found STA idx %d " MACDBG "\n",
|
i, MAC2STRDBG((char *)&sta_mac)));
|
|
*data = (wl_ap_sta_data_t*)&sta_data[i];
|
return BCME_OK;
|
}
|
}
|
}
|
|
return BCME_ERROR;
|
}
|
