// SPDX-License-Identifier: GPL-2.0
|
|
/******************************************************************************
|
*
|
* Copyright (C) 2020 SeekWave Technology Co.,Ltd.
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of version 2 of the GNU General Public License as
|
* published by the Free Software Foundation;
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*
|
******************************************************************************/
|
|
#include <linux/skbuff.h>
|
|
#include "skw_core.h"
|
#include "skw_cfg80211.h"
|
#include "skw_iface.h"
|
#include "skw_msg.h"
|
#include "skw_iw.h"
|
#include "skw_calib.h"
|
#include "skw_recovery.h"
|
#include "skw_mlme.h"
|
#include "skw_rx.h"
|
#include "skw_tx.h"
|
|
static inline void
|
skw_recovery_sta_disconnect(struct net_device *ndev, u8 *addr)
|
{
|
struct skw_iface *iface = netdev_priv(ndev);
|
|
if (iface->sta.sme_external)
|
skw_tx_mlme_mgmt(ndev, IEEE80211_STYPE_DEAUTH, addr, addr, 3);
|
else
|
skw_disconnected(ndev, 3, NULL, 0, true, GFP_KERNEL);
|
}
|
|
static int skw_recovery_sta(struct wiphy *wiphy, struct skw_recovery_data *rd,
|
struct skw_iface *iface)
|
{
|
int ret;
|
u32 peer_map = rd->iface[iface->id].peer_map;
|
struct skw_sta_core *core = &iface->sta.core;
|
struct net_device *dev = iface->ndev;
|
|
#ifdef SKW_STATE_RECOVERY
|
// TODO:
|
// recovery peer state
|
|
struct cfg80211_bss *cbss;
|
|
cbss = cfg80211_get_bss(wiphy, core->bss.channel, core->bss.bssid,
|
core->bss.ssid, core->bss.ssid_len,
|
IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
|
if (!cbss) {
|
if (!skw_cmd_unjoin(wiphy, dev, peer->addr, 3, true))
|
peer->flags |= SKW_PEER_FLAG_DEAUTHED;
|
|
skw_recovery_sta_disconnect(dev, core->bss.bssid);
|
return 0;
|
}
|
|
ret = skw_join(wiphy, dev, cbss, false);
|
if (ret) {
|
if (!skw_cmd_unjoin(wiphy, dev, peer->addr, 3, true))
|
peer->flags |= SKW_PEER_FLAG_DEAUTHED;
|
|
skw_recovery_sta_disconnect(dev, core->bss.bssid);
|
return 0;
|
}
|
|
// set key
|
// set ip
|
|
cfg80211_put_bss(wiphy, cbss);
|
#else
|
while (peer_map) {
|
u8 idx = ffs(peer_map) - 1;
|
struct skw_peer *peer = rd->peer[iface->lmac_id][idx];
|
|
SKW_CLEAR(peer_map, BIT(idx));
|
|
if (!peer || peer->flags & SKW_PEER_FLAG_DEAUTHED)
|
continue;
|
|
if (ether_addr_equal(peer->addr, core->bss.bssid)) {
|
del_timer_sync(&core->timer);
|
cancel_work_sync(&iface->sta.work);
|
|
ret = skw_cmd_unjoin(wiphy, dev, peer->addr,
|
SKW_LEAVE, true);
|
if (ret)
|
skw_warn("failed, sta: %pM, ret: %d\n",
|
peer->addr, ret);
|
|
skw_set_state(&core->sm, SKW_STATE_NONE);
|
memset(&core->bss, 0, sizeof(struct skw_bss_cfg));
|
core->bss.ctx_idx = SKW_INVALID_ID;
|
|
skw_recovery_sta_disconnect(dev, peer->addr);
|
peer->flags |= SKW_PEER_FLAG_DEAUTHED;
|
|
} else {
|
/* TDLS */
|
cfg80211_tdls_oper_request(dev, peer->addr,
|
NL80211_TDLS_TEARDOWN,
|
SKW_WLAN_REASON_TDLS_TEARDOWN_UNREACHABLE,
|
GFP_KERNEL);
|
|
peer->flags |= SKW_PEER_FLAG_DEAUTHED;
|
}
|
}
|
|
atomic_set(&iface->actived_ctx, 0);
|
#endif
|
|
return 0;
|
}
|
|
static void
|
skw_recovery_sap_flush_sta(struct wiphy *wiphy, struct skw_recovery_data *rd,
|
struct skw_iface *iface, u8 subtype, u16 reason)
|
{
|
int idx, ret;
|
u8 addr[ETH_ALEN];
|
struct skw_peer *peer;
|
struct skw_core *skw = wiphy_priv(wiphy);
|
u32 peer_map = rd->iface[iface->id].peer_map;
|
u8 lmac_id = iface->lmac_id;
|
|
while (peer_map) {
|
|
if (test_bit(SKW_FLAG_FW_ASSERT, &skw->flags))
|
break;
|
|
idx = ffs(peer_map) - 1;
|
SKW_CLEAR(peer_map, BIT(idx));
|
|
peer = rd->peer[lmac_id][idx];
|
if (!peer || peer->flags & SKW_PEER_FLAG_DEAUTHED)
|
continue;
|
|
peer->flags |= SKW_PEER_FLAG_DEAUTHED;
|
skw_mlme_ap_remove_client(iface, peer->addr);
|
skw_del_sta_event(iface, peer->addr, SKW_LEAVE);
|
}
|
|
memset(addr, 0xff, ETH_ALEN);
|
ret = skw_cmd_del_sta(wiphy, iface->ndev, addr, subtype, reason, true);
|
if (ret)
|
skw_warn("failed, sta: %pM, ret: %d\n", addr, ret);
|
}
|
|
static int skw_recovery_sap(struct wiphy *wiphy, struct skw_recovery_data *rd,
|
struct skw_iface *iface)
|
{
|
int ret, size;
|
struct skw_startap_param *param;
|
struct net_device *ndev = iface->ndev;
|
struct skw_startap_resp resp = {};
|
|
param = rd->iface[iface->id].param;
|
if (!param) {
|
skw_err("invalid param\n");
|
return -EINVAL;
|
}
|
|
ret = skw_sap_set_mib(wiphy, iface->ndev,
|
(u8 *)param + param->beacon_tail_offset,
|
param->beacon_tail_len);
|
if (ret) {
|
skw_err("set tlv failed, ret: %d\n", ret);
|
return ret;
|
}
|
|
size = rd->iface[iface->id].size;
|
|
ret = skw_send_msg(wiphy, ndev, SKW_CMD_START_AP, param, size, &resp, sizeof(resp));
|
if (ret) {
|
skw_err("failed, ret: %d\n", ret);
|
return ret;
|
}
|
|
skw_startap_resp_handler(iface->skw, iface, &resp);
|
|
skw_dpd_set_coeff_params(wiphy, ndev, param->chan, param->center_chn1,
|
param->center_chn2, param->chan_width);
|
|
skw_recovery_sap_flush_sta(wiphy, rd, iface, 12, SKW_LEAVE);
|
|
return 0;
|
}
|
|
static int skw_recovery_ibss(struct wiphy *wiphy, struct skw_iface *iface)
|
{
|
return 0;
|
}
|
|
static int skw_recovery_p2p_dev(struct wiphy *wiphy, struct skw_iface *iface)
|
{
|
skw_dbg("done\n");
|
|
return 0;
|
}
|
|
static void
|
skw_recovery_prepare(struct skw_core *skw, struct skw_recovery_data *rd)
|
{
|
int i, j;
|
struct skw_peer_ctx *ctx;
|
struct skw_iface *iface;
|
|
skw->cmd.seq = 0;
|
skw->skw_event_sn = 0;
|
|
for (i = 0; i < SKW_MAX_LMAC_SUPPORT; i++) {
|
atomic_set(&skw->hw.lmac[i].fw_credit, 0);
|
|
WRITE_ONCE(skw->hw.lmac[i].iface_bitmap, 0);
|
}
|
|
if (test_and_set_bit(SKW_FLAG_FW_CHIP_RECOVERY, &skw->flags)) {
|
skw_info("received recovery event during recovery");
|
|
|
for (i = 0; i < SKW_MAX_LMAC_SUPPORT; i++) {
|
for (j = 0; j < SKW_MAX_PEER_SUPPORT; j++) {
|
ctx = &skw->hw.lmac[i].peer_ctx[j];
|
|
skw_peer_ctx_lock(ctx);
|
|
rcu_assign_pointer(ctx->entry, NULL);
|
ctx->peer = NULL;
|
|
skw_peer_ctx_unlock(ctx);
|
}
|
}
|
|
spin_lock_bh(&skw->vif.lock);
|
|
for (i = 0; i < SKW_NR_IFACE; i++) {
|
iface = skw->vif.iface[i];
|
if (!iface)
|
continue;
|
|
for (j = 0; j <= SKW_WMM_AC_MAX; j++) {
|
skb_queue_purge(&iface->txq[j]);
|
skb_queue_purge(&iface->tx_cache[j]);
|
}
|
|
atomic_set(&iface->peer_map, 0);
|
}
|
|
spin_unlock_bh(&skw->vif.lock);
|
|
return;
|
}
|
|
mutex_lock(&rd->lock);
|
for (i = 0; i < SKW_MAX_LMAC_SUPPORT; i++) {
|
for (j = 0; j < SKW_MAX_PEER_SUPPORT; j++) {
|
ctx = &skw->hw.lmac[i].peer_ctx[j];
|
|
skw_peer_ctx_lock(ctx);
|
|
rcu_assign_pointer(ctx->entry, NULL);
|
rd->peer[i][j] = ctx->peer;
|
ctx->peer = NULL;
|
|
skw_peer_ctx_unlock(ctx);
|
}
|
}
|
|
spin_lock_bh(&skw->vif.lock);
|
|
for (i = 0; i < SKW_NR_IFACE; i++) {
|
iface = skw->vif.iface[i];
|
if (!iface)
|
continue;
|
|
for (j = 0; j <= SKW_WMM_AC_MAX; j++) {
|
skb_queue_purge(&iface->txq[j]);
|
skb_queue_purge(&iface->tx_cache[j]);
|
}
|
|
rd->iface[i].peer_map = atomic_read(&iface->peer_map);
|
atomic_set(&iface->peer_map, 0);
|
}
|
|
spin_unlock_bh(&skw->vif.lock);
|
|
mutex_unlock(&rd->lock);
|
|
skw_dpd_zero(&skw->dpd);
|
}
|
|
static int skw_recovery_iface(struct work_struct *wk, u8 iface_idx)
|
{
|
int ret = 0;
|
struct skw_core *skw = container_of(wk, struct skw_core, recovery_work);
|
struct wiphy *wiphy = priv_to_wiphy(skw);
|
struct skw_recovery_data *rd = &skw->recovery_data;
|
struct skw_iface *iface = skw->vif.iface[iface_idx];
|
|
if (!iface)
|
goto ret;
|
|
if (test_bit(SKW_FLAG_FW_ASSERT, &skw->flags)) {
|
ret = -EAGAIN;
|
goto ret;
|
}
|
|
skw_info("%s: inst: %d\n",
|
skw_iftype_name(iface->wdev.iftype), iface_idx);
|
|
ret = skw_cmd_open_dev(wiphy, iface->id, iface->addr,
|
iface->wdev.iftype, 0);
|
if (ret) {
|
skw_err("open %s failed, inst: %d, ret: %d\n",
|
skw_iftype_name(iface->wdev.iftype),
|
iface->id, ret);
|
|
skw_hw_assert(skw, false);
|
|
goto ret;
|
}
|
|
spin_lock_bh(&skw->vif.lock);
|
SKW_SET(iface->flags, SKW_IFACE_FLAG_OPENED);
|
skw->vif.opened_dev++;
|
spin_unlock_bh(&skw->vif.lock);
|
|
mutex_lock(&rd->lock);
|
|
switch (iface->wdev.iftype) {
|
case NL80211_IFTYPE_STATION:
|
if (iface->flags & SKW_IFACE_FLAG_LEGACY_P2P_DEV) {
|
skw_recovery_p2p_dev(wiphy, iface);
|
break;
|
}
|
|
skw_fallthrough;
|
|
case NL80211_IFTYPE_P2P_CLIENT:
|
skw_recovery_sta(wiphy, rd, iface);
|
break;
|
|
case NL80211_IFTYPE_AP:
|
case NL80211_IFTYPE_P2P_GO:
|
skw_recovery_sap(wiphy, rd, iface);
|
break;
|
|
case NL80211_IFTYPE_ADHOC:
|
skw_recovery_ibss(wiphy, iface);
|
break;
|
|
case NL80211_IFTYPE_P2P_DEVICE:
|
skw_recovery_p2p_dev(wiphy, iface);
|
break;
|
|
default:
|
break;
|
}
|
|
mutex_unlock(&rd->lock);
|
|
ret:
|
return ret;
|
}
|
|
static void skw_recovery_work(struct work_struct *wk)
|
{
|
int i, j, ret;
|
struct skw_chip_info chip;
|
struct skw_core *skw = container_of(wk, struct skw_core, recovery_work);
|
struct wiphy *wiphy = priv_to_wiphy(skw);
|
struct skw_recovery_data *rd = &skw->recovery_data;
|
struct skw_iface *iface;
|
|
skw_info("start\n");
|
|
skw_recovery_prepare(skw, rd);
|
|
spin_lock_bh(&skw->vif.lock);
|
skw->vif.opened_dev = 0;
|
for (i = 0; i < SKW_NR_IFACE; i++) {
|
iface = skw->vif.iface[i];
|
|
if (iface)
|
SKW_CLEAR(iface->flags, SKW_IFACE_FLAG_OPENED);
|
}
|
spin_unlock_bh(&skw->vif.lock);
|
|
skw_wifi_enable(skw->hw_pdata);
|
|
ret = skw_register_rx_callback(skw, skw_rx_cb, skw, skw_rx_cb, skw);
|
if (ret < 0)
|
skw_err("register rx callback failed, ret: %d\n", ret);
|
|
skw_hw_xmit_init(skw, skw->hw.dma);
|
|
clear_bit(SKW_FLAG_FW_ASSERT, &skw->flags);
|
clear_bit(SKW_FLAG_BLOCK_TX, &skw->flags);
|
clear_bit(SKW_FLAG_FW_MAC_RECOVERY, &skw->flags);
|
clear_bit(SKW_FLAG_FW_THERMAL, &skw->flags);
|
|
skw_sync_cmd_event_version(wiphy);
|
|
ret = skw_sync_chip_info(wiphy, &chip);
|
if (ret) {
|
skw_err("sync chip info failed, ret: %d\n", ret);
|
goto ret;
|
}
|
|
ret = skw_calib_download(wiphy, skw->fw.calib_file);
|
if (ret) {
|
skw_err("calib download failed, ret: %d\n", ret);
|
goto ret;
|
}
|
|
for (i = 0; i < SKW_NR_IFACE; i++) {
|
struct skw_iface *iface = skw->vif.iface[i];
|
|
if (!iface)
|
continue;
|
|
if (iface->wdev.iftype == NL80211_IFTYPE_STATION ||
|
iface->wdev.iftype == NL80211_IFTYPE_P2P_DEVICE) {
|
ret = skw_recovery_iface(wk, i);
|
if (ret)
|
goto ret;
|
}
|
}
|
|
for (i = 0; i < SKW_NR_IFACE; i++) {
|
struct skw_iface *iface = skw->vif.iface[i];
|
|
if (!iface)
|
continue;
|
|
if (!(iface->wdev.iftype == NL80211_IFTYPE_STATION ||
|
iface->wdev.iftype == NL80211_IFTYPE_P2P_DEVICE)) {
|
ret = skw_recovery_iface(wk, i);
|
if (ret)
|
goto ret;
|
}
|
}
|
|
if (!ret) {
|
for (i = 0; i < SKW_MAX_LMAC_SUPPORT; i++) {
|
for (j = 0; j < SKW_MAX_PEER_SUPPORT; j++) {
|
skw_peer_free(rd->peer[i][j]);
|
rd->peer[i][j] = NULL;
|
}
|
}
|
|
clear_bit(SKW_FLAG_FW_CHIP_RECOVERY, &skw->flags);
|
|
#ifdef CONFIG_SWT6621S_USB3_WORKAROUND
|
if (test_bit(SKW_FLAG_SWITCHING_USB_MODE, &skw->flags)) {
|
skw_dbg("usb switch done");
|
complete(&skw->usb_switch_done);
|
}
|
#endif
|
}
|
|
ret:
|
skw_dbg("end %d\n", ret);
|
}
|
|
void skw_recovery_del_peer(struct skw_iface *iface, u8 peer_idx)
|
{
|
struct skw_recovery_data *rd = &iface->skw->recovery_data;
|
u8 lmac_id = iface->lmac_id;
|
|
if (!test_bit(SKW_FLAG_FW_CHIP_RECOVERY, &iface->skw->flags))
|
return;
|
|
mutex_lock(&rd->lock);
|
|
if (rd->peer[lmac_id])
|
rd->peer[lmac_id][peer_idx]->flags |= SKW_PEER_FLAG_DEAUTHED;
|
|
mutex_unlock(&rd->lock);
|
}
|
|
int skw_recovery_data_update(struct skw_iface *iface, void *param, int len)
|
{
|
void *data;
|
struct skw_recovery_data *rd = &iface->skw->recovery_data;
|
|
if (!param)
|
return 0;
|
|
data = SKW_ZALLOC(SKW_2K_SIZE, GFP_KERNEL);
|
if (!data)
|
return -ENOMEM;
|
|
memcpy(data, param, len);
|
|
mutex_lock(&rd->lock);
|
|
SKW_KFREE(rd->iface[iface->id].param);
|
|
rd->iface[iface->id].param = data;
|
rd->iface[iface->id].size = len;
|
|
mutex_unlock(&rd->lock);
|
|
return 0;
|
}
|
|
void skw_recovery_data_clear(struct skw_iface *iface)
|
{
|
struct skw_recovery_data *rd = &iface->skw->recovery_data;
|
|
mutex_lock(&rd->lock);
|
|
rd->iface[iface->id].size = 0;
|
rd->iface[iface->id].peer_map = 0;
|
SKW_KFREE(rd->iface[iface->id].param);
|
|
mutex_unlock(&rd->lock);
|
}
|
|
int skw_recovery_init(struct skw_core *skw)
|
{
|
mutex_init(&skw->recovery_data.lock);
|
INIT_WORK(&skw->recovery_work, skw_recovery_work);
|
#ifdef CONFIG_SWT6621S_USB3_WORKAROUND
|
init_completion(&skw->usb_switch_done);
|
#endif
|
|
return 0;
|
}
|
|
void skw_recovery_deinit(struct skw_core *skw)
|
{
|
int i, j;
|
struct skw_recovery_data *rd = &skw->recovery_data;
|
|
mutex_lock(&rd->lock);
|
|
cancel_work_sync(&skw->recovery_work);
|
|
for (i = 0; i < SKW_NR_IFACE; i++)
|
SKW_KFREE(rd->iface[i].param);
|
|
for (i = 0; i < SKW_MAX_LMAC_SUPPORT; i++) {
|
for (j = 0; j < SKW_MAX_PEER_SUPPORT; j++) {
|
skw_peer_free(rd->peer[i][j]);
|
rd->peer[i][j] = NULL;
|
}
|
}
|
|
mutex_unlock(&rd->lock);
|
}
|
