// 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/kernel.h>
|
#include <net/cfg80211.h>
|
|
#include "skw_dfs.h"
|
#include "skw_util.h"
|
#include "skw_cfg80211.h"
|
|
#define SKW_MIN_PPB_THRESH 50
|
#define SKW_PPB_THRESH_RATE(PPB, RATE) ((PPB * RATE + 100 - RATE) / 100)
|
#define SKW_PPB_THRESH(PPB) SKW_PPB_THRESH_RATE(PPB, SKW_MIN_PPB_THRESH)
|
#define SKW_PRF2PRI(PRF) ((1000000 + PRF / 2) / PRF)
|
|
/* percentage of pulse width tolerance */
|
#define SKW_WIDTH_TOLERANCE 5
|
#define SKW_WIDTH_LOWER(W) ((W * (100 - SKW_WIDTH_TOLERANCE) + 50) / 100)
|
#define SKW_WIDTH_UPPER(W) ((W * (100 + SKW_WIDTH_TOLERANCE) + 50) / 100)
|
|
#define SKW_ETSI_PATTERN(ID, WMIN, WMAX, PMIN, PMAX, PRF, PPB, CHIRP) \
|
{ \
|
.rule = { \
|
.type_id = ID, \
|
.width_min = SKW_WIDTH_LOWER(WMIN), \
|
.width_max = SKW_WIDTH_UPPER(WMAX), \
|
.pri_min = (SKW_PRF2PRI(PMAX) - SKW_PRI_TOLERANCE), \
|
.pri_max = (SKW_PRF2PRI(PMIN) * PRF + SKW_PRI_TOLERANCE), \
|
.nr_pri = PRF, \
|
.ppb = PPB * PRF, \
|
.ppb_thresh = SKW_PPB_THRESH(PPB), \
|
.max_pri_tolerance = SKW_PRI_TOLERANCE, \
|
.chirp = CHIRP \
|
} \
|
}
|
|
/* radar types as defined by ETSI EN-301-893 v1.5.1 */
|
static struct skw_radar_cfg skw_radar_etsi_cfgs[] = {
|
SKW_ETSI_PATTERN(0, 0, 1, 700, 700, 1, 18, false),
|
SKW_ETSI_PATTERN(1, 0, 5, 200, 1000, 1, 10, false),
|
SKW_ETSI_PATTERN(2, 0, 15, 200, 1600, 1, 15, false),
|
SKW_ETSI_PATTERN(3, 0, 15, 2300, 4000, 1, 25, false),
|
SKW_ETSI_PATTERN(4, 20, 30, 2000, 4000, 1, 20, false),
|
SKW_ETSI_PATTERN(5, 0, 2, 300, 400, 3, 10, false),
|
SKW_ETSI_PATTERN(6, 0, 2, 400, 1200, 3, 15, false),
|
};
|
|
#define SKW_FCC_PATTERN(ID, WMIN, WMAX, PMIN, PMAX, PRF, PPB, CHIRP) \
|
{ \
|
.rule = { \
|
.type_id = ID, \
|
.width_min = SKW_WIDTH_LOWER(WMIN), \
|
.width_max = SKW_WIDTH_UPPER(WMAX), \
|
.pri_min = PMIN - SKW_PRI_TOLERANCE, \
|
.pri_max = PMAX * PRF + SKW_PRI_TOLERANCE, \
|
.nr_pri = PRF, \
|
.ppb = PPB * PRF, \
|
.ppb_thresh = SKW_PPB_THRESH(PPB), \
|
.max_pri_tolerance = SKW_PRI_TOLERANCE, \
|
.chirp = CHIRP \
|
} \
|
}
|
|
static struct skw_radar_cfg skw_radar_fcc_cfgs[] = {
|
SKW_FCC_PATTERN(0, 0, 1, 1428, 1428, 1, 18, false),
|
SKW_FCC_PATTERN(101, 0, 1, 518, 938, 1, 57, false),
|
SKW_FCC_PATTERN(102, 0, 1, 938, 2000, 1, 27, false),
|
SKW_FCC_PATTERN(103, 0, 1, 2000, 3066, 1, 18, false),
|
SKW_FCC_PATTERN(2, 0, 5, 150, 230, 1, 23, false),
|
SKW_FCC_PATTERN(3, 6, 10, 200, 500, 1, 16, false),
|
SKW_FCC_PATTERN(4, 11, 20, 200, 500, 1, 12, false),
|
SKW_FCC_PATTERN(5, 50, 100, 1000, 2000, 1, 1, true),
|
SKW_FCC_PATTERN(6, 0, 1, 333, 333, 1, 9, false),
|
};
|
|
#define SKW_JP_PATTERN(ID, WMIN, WMAX, PMIN, PMAX, PRF, PPB, RATE, CHIRP) \
|
{ \
|
.rule = { \
|
.type_id = ID, \
|
.width_min = SKW_WIDTH_LOWER(WMIN), \
|
.width_max = SKW_WIDTH_UPPER(WMAX), \
|
.pri_min = PMIN - SKW_PRI_TOLERANCE, \
|
.pri_max = PMAX * PRF + SKW_PRI_TOLERANCE, \
|
.nr_pri = PRF, \
|
.ppb = PPB * PRF, \
|
.ppb_thresh = SKW_PPB_THRESH_RATE(PPB, RATE), \
|
.max_pri_tolerance = SKW_PRI_TOLERANCE, \
|
.chirp = CHIRP, \
|
} \
|
}
|
|
static struct skw_radar_cfg skw_radar_jp_cfgs[] = {
|
SKW_JP_PATTERN(0, 0, 1, 1428, 1428, 1, 18, 29, false),
|
SKW_JP_PATTERN(1, 2, 3, 3846, 3846, 1, 18, 29, false),
|
SKW_JP_PATTERN(2, 0, 1, 1388, 1388, 1, 18, 50, false),
|
SKW_JP_PATTERN(3, 0, 4, 4000, 4000, 1, 18, 50, false),
|
SKW_JP_PATTERN(4, 0, 5, 150, 230, 1, 23, 50, false),
|
SKW_JP_PATTERN(5, 6, 10, 200, 500, 1, 16, 50, false),
|
SKW_JP_PATTERN(6, 11, 20, 200, 500, 1, 12, 50, false),
|
SKW_JP_PATTERN(7, 50, 100, 1000, 2000, 1, 3, 50, true),
|
SKW_JP_PATTERN(5, 0, 1, 333, 333, 1, 9, 50, false),
|
};
|
|
static const struct skw_radar_info skw_radar_infos[] = {
|
[NL80211_DFS_UNSET] = {
|
.nr_cfg = 0,
|
.cfgs = NULL,
|
},
|
[NL80211_DFS_FCC] = {
|
.nr_cfg = ARRAY_SIZE(skw_radar_fcc_cfgs),
|
.cfgs = skw_radar_fcc_cfgs,
|
},
|
[NL80211_DFS_ETSI] = {
|
.nr_cfg = ARRAY_SIZE(skw_radar_etsi_cfgs),
|
.cfgs = skw_radar_etsi_cfgs,
|
},
|
[NL80211_DFS_JP] = {
|
.nr_cfg = ARRAY_SIZE(skw_radar_jp_cfgs),
|
.cfgs = skw_radar_jp_cfgs,
|
},
|
};
|
|
static void pool_put_pseq_elem(struct skw_core *skw, struct skw_pri_sequence *pse)
|
{
|
spin_lock_bh(&skw->dfs.skw_pool_lock);
|
|
list_add(&pse->head, &skw->dfs.skw_pseq_pool);
|
|
spin_unlock_bh(&skw->dfs.skw_pool_lock);
|
}
|
|
static void pool_put_pulse_elem(struct skw_core *skw, struct skw_pulse_elem *pe)
|
{
|
spin_lock_bh(&skw->dfs.skw_pool_lock);
|
|
list_add(&pe->head, &skw->dfs.skw_pulse_pool);
|
|
spin_unlock_bh(&skw->dfs.skw_pool_lock);
|
}
|
|
static struct skw_pulse_elem *pool_get_pulse_elem(struct skw_core *skw)
|
{
|
struct skw_pulse_elem *pe = NULL;
|
|
spin_lock_bh(&skw->dfs.skw_pool_lock);
|
|
if (!list_empty(&skw->dfs.skw_pulse_pool)) {
|
pe = list_first_entry(&skw->dfs.skw_pulse_pool, struct skw_pulse_elem, head);
|
list_del(&pe->head);
|
}
|
|
spin_unlock_bh(&skw->dfs.skw_pool_lock);
|
|
return pe;
|
}
|
|
static struct skw_pulse_elem *pulse_queue_get_tail(struct skw_pri_detector *pde)
|
{
|
struct list_head *l = &pde->pulses;
|
|
if (list_empty(l))
|
return NULL;
|
|
return list_entry(l->prev, struct skw_pulse_elem, head);
|
}
|
|
static bool pulse_queue_dequeue(struct skw_core *skw, struct skw_pri_detector *pde)
|
{
|
struct skw_pulse_elem *p = pulse_queue_get_tail(pde);
|
|
if (p != NULL) {
|
list_del_init(&p->head);
|
pde->count--;
|
/* give it back to pool */
|
pool_put_pulse_elem(skw, p);
|
}
|
|
return (pde->count > 0);
|
}
|
|
/* remove pulses older than window */
|
static void pulse_queue_check_window(struct skw_core *skw, struct skw_pri_detector *pde)
|
{
|
u64 min_valid_ts;
|
struct skw_pulse_elem *p;
|
|
/* there is no delta time with less than 2 pulses */
|
if (pde->count < 2)
|
return;
|
|
if (pde->last_ts <= pde->window_size)
|
return;
|
|
min_valid_ts = pde->last_ts - pde->window_size;
|
|
while ((p = pulse_queue_get_tail(pde)) != NULL) {
|
if (p->ts >= min_valid_ts)
|
return;
|
|
pulse_queue_dequeue(skw, pde);
|
}
|
}
|
|
static u32 pde_get_multiple(u32 val, u32 fraction, u32 tolerance)
|
{
|
u32 remainder;
|
u32 factor;
|
u32 delta;
|
|
if (fraction == 0)
|
return 0;
|
|
delta = (val < fraction) ? (fraction - val) : (val - fraction);
|
|
if (delta <= tolerance)
|
/* val and fraction are within tolerance */
|
return 1;
|
|
factor = val / fraction;
|
remainder = val % fraction;
|
if (remainder > tolerance) {
|
/* no exact match */
|
if ((fraction - remainder) <= tolerance)
|
/* remainder is within tolerance */
|
factor++;
|
else
|
factor = 0;
|
}
|
|
return factor;
|
}
|
|
static u32 pseq_handler_add_to_existing_seqs(struct skw_core *skw, struct skw_radar_cfg *cfg, u64 ts)
|
{
|
u32 max_count = 0;
|
struct skw_pri_sequence *ps, *ps2;
|
|
list_for_each_entry_safe(ps, ps2, &cfg->pri.sequences, head) {
|
u32 delta_ts;
|
u32 factor;
|
|
/* first ensure that sequence is within window */
|
if (ts > ps->deadline_ts) {
|
list_del_init(&ps->head);
|
pool_put_pseq_elem(skw, ps);
|
continue;
|
}
|
|
delta_ts = ts - ps->last_ts;
|
factor = pde_get_multiple(delta_ts, ps->pri,
|
cfg->rule.max_pri_tolerance);
|
if (factor > 0) {
|
ps->last_ts = ts;
|
ps->count++;
|
|
if (max_count < ps->count)
|
max_count = ps->count;
|
} else {
|
ps->count_falses++;
|
}
|
}
|
|
return max_count;
|
}
|
|
static struct skw_pri_sequence *pool_get_pseq_elem(struct skw_core *skw)
|
{
|
struct skw_pri_sequence *pse = NULL;
|
|
spin_lock_bh(&skw->dfs.skw_pool_lock);
|
|
if (!list_empty(&skw->dfs.skw_pseq_pool)) {
|
pse = list_first_entry(&skw->dfs.skw_pseq_pool, struct skw_pri_sequence, head);
|
list_del(&pse->head);
|
}
|
|
spin_unlock_bh(&skw->dfs.skw_pool_lock);
|
|
return pse;
|
}
|
|
#define GET_PRI_TO_USE(MIN, MAX, RUNTIME) \
|
(MIN + SKW_PRI_TOLERANCE == MAX - SKW_PRI_TOLERANCE ? \
|
MIN + SKW_PRI_TOLERANCE : RUNTIME)
|
static bool pseq_handler_create_sequences(struct skw_core *skw,
|
struct skw_radar_cfg *cfg, u64 ts, u32 min_count)
|
{
|
struct skw_pulse_elem *p;
|
|
list_for_each_entry(p, &cfg->pri.pulses, head) {
|
struct skw_pri_sequence ps, *new_ps;
|
struct skw_pulse_elem *p2;
|
u32 tmp_false_count;
|
u64 min_valid_ts;
|
u32 delta_ts = ts - p->ts;
|
|
if (delta_ts < cfg->rule.pri_min)
|
/* ignore too small pri */
|
continue;
|
|
if (delta_ts > cfg->rule.pri_max)
|
/* stop on too large pri (sorted list) */
|
break;
|
|
/* build a new sequence with new potential pri */
|
ps.count = 2;
|
ps.count_falses = 0;
|
ps.first_ts = p->ts;
|
ps.last_ts = ts;
|
ps.pri = GET_PRI_TO_USE(cfg->rule.pri_min, cfg->rule.pri_max, ts - p->ts);
|
ps.dur = ps.pri * (cfg->rule.ppb - 1) + 2 * cfg->rule.max_pri_tolerance;
|
|
p2 = p;
|
tmp_false_count = 0;
|
min_valid_ts = ts - ps.dur;
|
/* check which past pulses are candidates for new sequence */
|
list_for_each_entry_continue(p2, &cfg->pri.pulses, head) {
|
u32 factor;
|
|
if (p2->ts < min_valid_ts)
|
/* stop on crossing window border */
|
break;
|
/* check if pulse match (multi)PRI */
|
factor = pde_get_multiple(ps.last_ts - p2->ts, ps.pri,
|
cfg->rule.max_pri_tolerance);
|
if (factor > 0) {
|
ps.count++;
|
ps.first_ts = p2->ts;
|
/*
|
* on match, add the intermediate falses
|
* and reset counter
|
*/
|
ps.count_falses += tmp_false_count;
|
tmp_false_count = 0;
|
} else {
|
/* this is a potential false one */
|
tmp_false_count++;
|
}
|
}
|
|
if (ps.count <= min_count)
|
/* did not reach minimum count, drop sequence */
|
continue;
|
|
/* this is a valid one, add it */
|
ps.deadline_ts = ps.first_ts + ps.dur;
|
new_ps = pool_get_pseq_elem(skw);
|
if (new_ps == NULL) {
|
new_ps = kmalloc(sizeof(*new_ps), GFP_ATOMIC);
|
if (new_ps == NULL)
|
return false;
|
}
|
|
memcpy(new_ps, &ps, sizeof(ps));
|
INIT_LIST_HEAD(&new_ps->head);
|
list_add(&new_ps->head, &cfg->pri.sequences);
|
}
|
|
return true;
|
}
|
|
static void pri_detector_reset(struct skw_core *skw, struct skw_pri_detector *pde, u64 ts)
|
{
|
struct skw_pri_sequence *ps, *ps0;
|
struct skw_pulse_elem *p, *p0;
|
|
list_for_each_entry_safe(ps, ps0, &pde->sequences, head) {
|
list_del_init(&ps->head);
|
pool_put_pseq_elem(skw, ps);
|
}
|
|
list_for_each_entry_safe(p, p0, &pde->pulses, head) {
|
list_del_init(&p->head);
|
pool_put_pulse_elem(skw, p);
|
}
|
|
pde->count = 0;
|
pde->last_ts = ts;
|
}
|
|
static struct skw_pri_sequence *pseq_handler_check_detection(struct skw_radar_cfg *cfg)
|
{
|
struct skw_pri_sequence *ps;
|
|
if (list_empty(&cfg->pri.sequences))
|
return NULL;
|
|
list_for_each_entry(ps, &cfg->pri.sequences, head) {
|
/*
|
* we assume to have enough matching confidence if we
|
* 1) have enough pulses
|
* 2) have more matching than false pulses
|
*/
|
if ((ps->count >= cfg->rule.ppb_thresh) &&
|
(ps->count * cfg->rule.nr_pri >= ps->count_falses))
|
return ps;
|
}
|
|
return NULL;
|
}
|
|
static bool pulse_queue_enqueue(struct skw_core *skw, struct skw_pri_detector *pde, u64 ts)
|
{
|
struct skw_pulse_elem *p = pool_get_pulse_elem(skw);
|
|
if (p == NULL) {
|
p = kmalloc(sizeof(*p), GFP_ATOMIC);
|
if (p == NULL)
|
return false;
|
}
|
|
INIT_LIST_HEAD(&p->head);
|
|
p->ts = ts;
|
list_add(&p->head, &pde->pulses);
|
|
pde->count++;
|
pde->last_ts = ts;
|
pulse_queue_check_window(skw, pde);
|
|
if (pde->count >= pde->max_count)
|
pulse_queue_dequeue(skw, pde);
|
|
return true;
|
}
|
|
int skw_dfs_add_pulse(struct wiphy *wiphy, struct net_device *dev, struct skw_pulse_info *pulse)
|
{
|
int i;
|
bool reset = false;
|
u32 max_updated_seq;
|
struct skw_pri_sequence *ps;
|
struct skw_iface *iface = netdev_priv(dev);
|
struct skw_core *skw = wiphy_priv(wiphy);
|
|
if (!iface->sap.dfs.flags)
|
return 0;
|
|
if (skw->dfs.last_pulse_ts > pulse->ts)
|
reset = true;
|
|
skw->dfs.last_pulse_ts = pulse->ts;
|
|
for (i = 0; i < skw->dfs.info->nr_cfg; i++) {
|
struct skw_radar_cfg *cfg = &skw->dfs.info->cfgs[i];
|
const struct skw_radar_rule *rule = &cfg->rule;
|
|
if (reset) {
|
pri_detector_reset(skw, &cfg->pri, skw->dfs.last_pulse_ts);
|
continue;
|
}
|
|
if ((rule->width_min > pulse->width) || (rule->width_max < pulse->width)) {
|
skw_detail("invalid pulse width, (%d - %d), pulse width: %d\n",
|
rule->width_min, rule->width_max, pulse->width);
|
continue;
|
}
|
|
if (rule->chirp && rule->chirp != pulse->chirp) {
|
skw_detail("invalid chirp\n");
|
continue;
|
}
|
|
if ((pulse->ts - cfg->pri.last_ts) < rule->max_pri_tolerance) {
|
skw_detail("invalid timestap, %lld - %lld = %lld, max: %d\n",
|
pulse->ts, cfg->pri.last_ts, pulse->ts - cfg->pri.last_ts,
|
rule->max_pri_tolerance);
|
continue;
|
}
|
|
max_updated_seq = pseq_handler_add_to_existing_seqs(skw, cfg, pulse->ts);
|
if (!pseq_handler_create_sequences(skw, cfg, pulse->ts, max_updated_seq)) {
|
pri_detector_reset(skw, &cfg->pri, pulse->ts);
|
continue;
|
}
|
|
ps = pseq_handler_check_detection(cfg);
|
if (ps) {
|
skw_info("radar deteced, iface dfs flags: 0x%lx\n", iface->sap.dfs.flags);
|
|
skw_dfs_deinit(wiphy, dev);
|
|
cfg80211_radar_event(wiphy, &skw->dfs.chan, GFP_KERNEL);
|
|
break;
|
}
|
|
pulse_queue_enqueue(skw, &cfg->pri, pulse->ts);
|
}
|
|
return 0;
|
}
|
|
static void skw_dfs_cac_work(struct work_struct *work)
|
{
|
struct delayed_work *dwk = to_delayed_work(work);
|
struct skw_iface *iface = container_of(dwk, struct skw_iface,
|
sap.dfs.cac_work);
|
|
skw_dbg("dev: %s finished\n", netdev_name(iface->ndev));
|
|
skw_wdev_lock(&iface->wdev);
|
|
if (iface->wdev.cac_started) {
|
skw_dfs_stop_cac(priv_to_wiphy(iface->skw), iface->ndev);
|
|
cfg80211_cac_event(iface->ndev, &iface->skw->dfs.chan,
|
NL80211_RADAR_CAC_FINISHED, GFP_KERNEL);
|
}
|
|
skw_wdev_unlock(&iface->wdev);
|
}
|
|
int skw_dfs_chan_init(struct wiphy *wiphy, struct net_device *dev,
|
struct cfg80211_chan_def *chandef, u32 cac_time_ms)
|
{
|
int i;
|
struct skw_core *skw = wiphy_priv(wiphy);
|
struct skw_iface *iface = netdev_priv(dev);
|
|
skw_dbg("chan: %d, dfs region: %d, flags: 0x%lx\n",
|
chandef->chan->hw_value, skw->dfs.region,
|
skw->dfs.flags);
|
|
if (!skw->dfs.fw_enabled)
|
return -ENOTSUPP;
|
|
if (skw->dfs.flags) {
|
if (skw->dfs.chan.width != chandef->width ||
|
skw->dfs.chan.chan != chandef->chan) {
|
skw_warn("current chan: %d, require chan: %d\n",
|
skw->dfs.chan.chan->hw_value,
|
chandef->chan->hw_value);
|
|
return -EBUSY;
|
}
|
}
|
|
if (skw->dfs.region >= ARRAY_SIZE(skw_radar_infos)) {
|
skw_err("invalid dfs region: %d\n", skw->dfs.region);
|
|
return -EINVAL;
|
}
|
|
skw->dfs.info = &skw_radar_infos[skw->dfs.region];
|
if (!skw->dfs.info->nr_cfg || !skw->dfs.info->cfgs) {
|
skw_err("invalid, region: %d, nr_cfg: %d\n",
|
skw->dfs.region, skw->dfs.info->nr_cfg);
|
|
return -EINVAL;
|
}
|
|
iface->sap.dfs.cac_time_ms = cac_time_ms;
|
skw->dfs.last_pulse_ts = 0;
|
skw->dfs.chan = *chandef;
|
|
for (i = 0; i < skw->dfs.info->nr_cfg; i++) {
|
struct skw_radar_cfg *cfg = &skw->dfs.info->cfgs[i];
|
const struct skw_radar_rule *rule = &cfg->rule;
|
|
INIT_LIST_HEAD(&cfg->pri.sequences);
|
INIT_LIST_HEAD(&cfg->pri.pulses);
|
|
cfg->pri.window_size = rule->pri_max * rule->ppb * rule->nr_pri;
|
cfg->pri.max_count = rule->ppb * 2;
|
}
|
|
return 0;
|
}
|
|
int skw_dfs_start_cac(struct wiphy *wiphy, struct net_device *dev)
|
{
|
int ret;
|
struct skw_dfs_cac cac;
|
struct skw_core *skw = wiphy_priv(wiphy);
|
struct skw_iface *iface = netdev_priv(dev);
|
|
skw_dbg("%s\n", netdev_name(dev));
|
|
if (!skw->dfs.fw_enabled)
|
return -ENOTSUPP;
|
|
cac.type = SKW_DFS_START_CAC;
|
cac.len = sizeof(struct skw_cac_params);
|
|
cac.params.chn = skw->dfs.chan.chan->hw_value;
|
cac.params.center_chn1 = skw_freq_to_chn(skw->dfs.chan.center_freq1);
|
cac.params.center_chn2 = skw_freq_to_chn(skw->dfs.chan.center_freq2);
|
cac.params.band_width = to_skw_bw(skw->dfs.chan.width);
|
cac.params.region = skw->dfs.region;
|
cac.params.time_ms = iface->sap.dfs.cac_time_ms;
|
|
ret = skw_send_msg(wiphy, dev, SKW_CMD_DFS, &cac, sizeof(cac), NULL, 0);
|
if (!ret) {
|
set_bit(SKW_DFS_FLAG_CAC_MODE, &iface->sap.dfs.flags);
|
set_bit(SKW_DFS_FLAG_CAC_MODE, &skw->dfs.flags);
|
}
|
|
return ret;
|
}
|
|
int skw_dfs_stop_cac(struct wiphy *wiphy, struct net_device *dev)
|
{
|
struct skw_dfs_cac cac;
|
struct skw_core *skw = wiphy_priv(wiphy);
|
struct skw_iface *iface = netdev_priv(dev);
|
|
skw_dbg("%s\n", netdev_name(dev));
|
|
if (!skw->dfs.fw_enabled)
|
return -ENOTSUPP;
|
|
cac.type = SKW_DFS_STOP_CAC;
|
cac.len = 0;
|
|
clear_bit(SKW_DFS_FLAG_CAC_MODE, &iface->sap.dfs.flags);
|
clear_bit(SKW_DFS_FLAG_CAC_MODE, &skw->dfs.flags);
|
|
return skw_send_msg(wiphy, dev, SKW_CMD_DFS, &cac, sizeof(cac), NULL, 0);
|
}
|
|
int skw_dfs_start_monitor(struct wiphy *wiphy, struct net_device *dev)
|
{
|
int ret;
|
struct skw_dfs_cac cac;
|
struct skw_core *skw = wiphy_priv(wiphy);
|
struct skw_iface *iface = netdev_priv(dev);
|
|
skw_dbg("%s\n", netdev_name(dev));
|
|
if (!skw->dfs.fw_enabled)
|
return -ENOTSUPP;
|
|
cac.type = SKW_DFS_START_MONITOR;
|
cac.len = 0;
|
|
ret = skw_send_msg(wiphy, dev, SKW_CMD_DFS, &cac, sizeof(cac), NULL, 0);
|
if (!ret) {
|
set_bit(SKW_DFS_FLAG_MONITOR_MODE, &skw->dfs.flags);
|
set_bit(SKW_DFS_FLAG_MONITOR_MODE, &iface->sap.dfs.flags);
|
}
|
|
return ret;
|
}
|
|
int skw_dfs_stop_monitor(struct wiphy *wiphy, struct net_device *dev)
|
{
|
struct skw_dfs_cac cac;
|
struct skw_core *skw = wiphy_priv(wiphy);
|
struct skw_iface *iface = netdev_priv(dev);
|
|
skw_dbg("%s\n", netdev_name(dev));
|
|
if (!skw->dfs.fw_enabled)
|
return -ENOTSUPP;
|
|
cac.type = SKW_DFS_STOP_MONITOR;
|
cac.len = 0;
|
|
clear_bit(SKW_DFS_FLAG_MONITOR_MODE, &skw->dfs.flags);
|
clear_bit(SKW_DFS_FLAG_MONITOR_MODE, &iface->sap.dfs.flags);
|
|
return skw_send_msg(wiphy, dev, SKW_CMD_DFS, &cac, sizeof(cac), NULL, 0);
|
}
|
|
int skw_dfs_init(struct wiphy *wiphy, struct net_device *dev)
|
{
|
int i, j;
|
struct skw_iface *iface = netdev_priv(dev);
|
|
BUILD_BUG_ON(IS_ENABLED(CONFIG_SWT6621S_REGD_SELF_MANAGED));
|
|
iface->sap.dfs.flags = 0;
|
INIT_DELAYED_WORK(&iface->sap.dfs.cac_work, skw_dfs_cac_work);
|
|
for (i = 0; i < ARRAY_SIZE(skw_radar_infos); i++) {
|
const struct skw_radar_info *info = &skw_radar_infos[i];
|
|
for (j = 0; j < info->nr_cfg; j++) {
|
INIT_LIST_HEAD(&info->cfgs[j].pri.sequences);
|
INIT_LIST_HEAD(&info->cfgs[j].pri.pulses);
|
}
|
}
|
|
return 0;
|
}
|
|
int skw_dfs_deinit(struct wiphy *wiphy, struct net_device *dev)
|
{
|
int i, j;
|
struct skw_core *skw = wiphy_priv(wiphy);
|
struct skw_iface *iface = netdev_priv(dev);
|
|
if (test_bit(SKW_DFS_FLAG_CAC_MODE, &iface->sap.dfs.flags)) {
|
|
cancel_delayed_work_sync(&iface->sap.dfs.cac_work);
|
|
skw_dfs_stop_cac(wiphy, dev);
|
|
cfg80211_cac_event(dev, &skw->dfs.chan,
|
NL80211_RADAR_CAC_ABORTED, GFP_KERNEL);
|
}
|
|
if (test_bit(SKW_DFS_FLAG_MONITOR_MODE, &iface->sap.dfs.flags))
|
skw_dfs_stop_monitor(wiphy, dev);
|
|
for (i = 0; i < ARRAY_SIZE(skw_radar_infos); i++) {
|
const struct skw_radar_info *info = &skw_radar_infos[i];
|
|
for (j = 0; j < info->nr_cfg; j++)
|
pri_detector_reset(skw, &info->cfgs[j].pri, 0);
|
}
|
|
return 0;
|
}
|
