From 0c590ceba40efc750f3a9b877b0ab9cbc8afc906 Mon Sep 17 00:00:00 2001 From: bings Date: Tue, 23 Jan 2018 16:20:29 +0800 Subject: [PATCH] qcacmn: Move dfs leakage from qcacld to qcacmn Move dfs leakage from qcacld to dfs module of qcacmn. Change-Id: I17276fedf575f1a4029265be58d8fd088c1d956d CRs-Fixed: 2177679 --- umac/dfs/core/src/dfs.h | 2 + umac/dfs/core/src/dfs_random_chan_sel.h | 57 +- umac/dfs/core/src/misc/dfs_random_chan_sel.c | 872 ++++++++++++++++++- umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h | 12 + umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h | 20 + umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c | 19 + umac/dfs/dispatcher/src/wlan_dfs_utils_api.c | 19 + 7 files changed, 997 insertions(+), 4 deletions(-) diff --git a/umac/dfs/core/src/dfs.h b/umac/dfs/core/src/dfs.h index a63f69f72a68..b336588839e6 100644 --- a/umac/dfs/core/src/dfs.h +++ b/umac/dfs/core/src/dfs.h @@ -912,6 +912,7 @@ struct dfs_event_log { * @dfs_is_offload_enabled: Set if DFS offload enabled. * @dfs_use_nol: Use the NOL when radar found(default: TRUE) * @dfs_nol_lock: Lock to protect nol list. + * @tx_leakage_threshold: Tx leakage threshold for dfs. */ struct wlan_dfs { uint32_t dfs_debug_mask; @@ -1009,6 +1010,7 @@ struct wlan_dfs { bool dfs_is_offload_enabled; int dfs_use_nol; qdf_spinlock_t dfs_nol_lock; + uint16_t tx_leakage_threshold; }; /** diff --git a/umac/dfs/core/src/dfs_random_chan_sel.h b/umac/dfs/core/src/dfs_random_chan_sel.h index 61337b797ac0..dad79687e4be 100644 --- a/umac/dfs/core/src/dfs_random_chan_sel.h +++ b/umac/dfs/core/src/dfs_random_chan_sel.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved. + * Copyright (c) 2012-2018 The Linux Foundation. All rights reserved. * * Previously licensed under the ISC license by Qualcomm Atheros, Inc. * @@ -114,6 +114,21 @@ /* Max valid channel number */ #define MAX_CHANNEL_NUM 184 +#ifdef WLAN_ENABLE_CHNL_MATRIX_RESTRICTION +#define DFS_TX_LEAKAGE_THRES 310 +#define DFS_TX_LEAKAGE_MAX 1000 +#define DFS_TX_LEAKAGE_MIN 200 + +/* + * This define is used to block additional channels + * based on the new data gathered on auto platforms + * and to differentiate the leakage data among different + * platforms. + */ + +#define DFS_TX_LEAKAGE_AUTO_MIN 210 +#endif + #define DFS_IS_CHANNEL_WEATHER_RADAR(_f) (((_f) >= 5600) && ((_f) <= 5650)) #define DFS_IS_CHAN_JAPAN_INDOOR(_ch) (((_ch) >= 36) && ((_ch) <= 64)) #define DFS_IS_CHAN_JAPAN_OUTDOOR(_ch) (((_ch) >= 100) && ((_ch) <= 140)) @@ -139,6 +154,46 @@ struct chan_bonding_bitmap { struct chan_bonding_info chan_bonding_set[DFS_MAX_80MHZ_BANDS]; }; +#ifdef WLAN_ENABLE_CHNL_MATRIX_RESTRICTION +/** + * struct dfs_tx_leak_info - DFS leakage info + * @leak_chan: leak channel. + * @leak_lvl: tx leakage lvl. + */ +struct dfs_tx_leak_info { + uint8_t leak_chan; + uint32_t leak_lvl; +}; + +/** + * struct dfs_matrix_tx_leak_info - DFS leakage matrix info for dfs channel. + * @channel: channel to switch from + * @chan_matrix DFS leakage matrix info for given dfs channel. + */ +struct dfs_matrix_tx_leak_info { + uint8_t channel; + struct dfs_tx_leak_info chan_matrix[CHAN_ENUM_144 - CHAN_ENUM_36 + 1]; +}; +#endif + +/** + * dfs_mark_leaking_ch() - to mark channel leaking in to nol + * @dfs: dfs handler. + * @ch_width: channel width + * @temp_ch_lst_sz: the target channel list + * @temp_ch_lst: the target channel list + * + * This function removes the channels from temp channel list that + * (if selected as target channel) will cause leakage in one of + * the NOL channels + * + * Return: QDF_STATUS + */ +QDF_STATUS dfs_mark_leaking_ch(struct wlan_dfs *dfs, + enum phy_ch_width ch_width, + uint8_t temp_ch_lst_sz, + uint8_t *temp_ch_lst); + /** * dfs_prepare_random_channel() - This function picks a random channel from * the list of available channels. diff --git a/umac/dfs/core/src/misc/dfs_random_chan_sel.c b/umac/dfs/core/src/misc/dfs_random_chan_sel.c index 85610d22d3e5..5e4cf6ae9e98 100644 --- a/umac/dfs/core/src/misc/dfs_random_chan_sel.c +++ b/umac/dfs/core/src/misc/dfs_random_chan_sel.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2017 The Linux Foundation. All rights reserved. + * Copyright (c) 2012-2018 The Linux Foundation. All rights reserved. * * Previously licensed under the ISC license by Qualcomm Atheros, Inc. * @@ -28,6 +28,835 @@ #include "../dfs.h" #include "../dfs_random_chan_sel.h" #include +#include + +#ifdef WLAN_ENABLE_CHNL_MATRIX_RESTRICTION +/* + * TODO: At present SAP Channel leakage matrix for ch 144 + * is not available from system's team. So to play it safe + * and avoid crash if channel 144 is request, in following + * matix channel 144 is added such that it will cause code + * to avoid selecting channel 144. + * + * THESE ENTRIES SHOULD BE REPLACED WITH CORRECT VALUES AS + * PROVIDED BY SYSTEM'S TEAM. + */ + +/* channel tx leakage table - ht80 */ +struct dfs_matrix_tx_leak_info ht80_chan[] = { + {52, + {{36, 148}, {40, 199}, + {44, 193}, {48, 197}, + {52, DFS_TX_LEAKAGE_MIN}, {56, 153}, + {60, 137}, {64, 134}, + {100, 358}, {104, 350}, + {108, 404}, {112, 344}, + {116, 424}, {120, 429}, + {124, 437}, {128, 435}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + + {56, + {{36, 171}, {40, 178}, + {44, 171}, {48, 178}, + {52, DFS_TX_LEAKAGE_MIN}, {56, DFS_TX_LEAKAGE_MIN}, + {60, DFS_TX_LEAKAGE_MIN}, {64, 280}, + {100, 351}, {104, 376}, + {108, 362}, {112, 362}, + {116, 403}, {120, 397}, + {124, DFS_TX_LEAKAGE_MAX}, {128, DFS_TX_LEAKAGE_MAX}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {60, + {{36, 156}, {40, 146}, + {44, DFS_TX_LEAKAGE_MIN}, {48, DFS_TX_LEAKAGE_MIN}, + {52, 180}, {56, DFS_TX_LEAKAGE_MIN}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, 376}, {104, 360}, + {108, DFS_TX_LEAKAGE_MAX}, {112, DFS_TX_LEAKAGE_MAX}, + {116, 395}, {120, 399}, + {124, DFS_TX_LEAKAGE_MAX}, {128, DFS_TX_LEAKAGE_MAX}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {64, + {{36, 217}, {40, 221}, + {44, DFS_TX_LEAKAGE_MIN}, {48, DFS_TX_LEAKAGE_MIN}, + {52, 176}, {56, 176}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, 384}, {104, 390}, + {108, DFS_TX_LEAKAGE_MAX}, {112, DFS_TX_LEAKAGE_MAX}, + {116, 375}, {120, 374}, + {124, DFS_TX_LEAKAGE_MAX}, {128, DFS_TX_LEAKAGE_MAX}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {100, + {{36, 357}, {40, 326}, + {44, 321}, {48, 326}, + {52, 378}, {56, 396}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, DFS_TX_LEAKAGE_MIN}, {104, DFS_TX_LEAKAGE_MIN}, + {108, 196}, {112, 116}, + {116, 166}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {104, + {{36, 325}, {40, 325}, + {44, 305}, {48, 352}, + {52, 411}, {56, 411}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, DFS_TX_LEAKAGE_MIN}, {104, DFS_TX_LEAKAGE_MIN}, + {108, DFS_TX_LEAKAGE_MIN}, {112, 460}, + {116, 198}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {108, + {{36, 304}, {40, 332}, + {44, 310}, {48, 335}, + {52, 431}, {56, 391}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, 280}, {104, DFS_TX_LEAKAGE_MIN}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, 185}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {112, + {{36, 327}, {40, 335}, + {44, 331}, {48, 345}, + {52, 367}, {56, 401}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, 131}, {104, 132}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, 189}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {116, + {{36, 384}, {40, 372}, + {44, 389}, {48, 396}, + {52, 348}, {56, 336}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, 172}, {104, 169}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, DFS_TX_LEAKAGE_MIN}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {120, + {{36, 395}, {40, 419}, + {44, 439}, {48, 407}, + {52, 321}, {56, 334}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, 134}, {104, 186}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, DFS_TX_LEAKAGE_MIN}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, 159}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {124, + {{36, 469}, {40, 433}, + {44, 434}, {48, 435}, + {52, 332}, {56, 345}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, 146}, {104, 177}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, 350}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, 138}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {128, + {{36, 408}, {40, 434}, + {44, 449}, {48, 444}, + {52, 341}, {56, 374}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, 205}, {104, 208}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, 142}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {132, + {{36, DFS_TX_LEAKAGE_MAX}, {40, DFS_TX_LEAKAGE_MAX}, + {44, DFS_TX_LEAKAGE_MAX}, {48, DFS_TX_LEAKAGE_MAX}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, DFS_TX_LEAKAGE_MIN}, {104, DFS_TX_LEAKAGE_MIN}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, DFS_TX_LEAKAGE_MIN}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {136, + {{36, DFS_TX_LEAKAGE_MAX}, {40, DFS_TX_LEAKAGE_MAX}, + {44, DFS_TX_LEAKAGE_MAX}, {48, DFS_TX_LEAKAGE_MAX}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, DFS_TX_LEAKAGE_MIN}, {104, DFS_TX_LEAKAGE_MIN}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, DFS_TX_LEAKAGE_MIN}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {140, + {{36, DFS_TX_LEAKAGE_MAX}, {40, DFS_TX_LEAKAGE_MAX}, + {44, DFS_TX_LEAKAGE_MAX}, {48, DFS_TX_LEAKAGE_MAX}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, DFS_TX_LEAKAGE_MIN}, {104, DFS_TX_LEAKAGE_MIN}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, DFS_TX_LEAKAGE_MIN}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {144, + {{36, DFS_TX_LEAKAGE_MAX}, {40, DFS_TX_LEAKAGE_MAX}, + {44, DFS_TX_LEAKAGE_MAX}, {48, DFS_TX_LEAKAGE_MAX}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, DFS_TX_LEAKAGE_MIN}, {104, DFS_TX_LEAKAGE_MIN}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, DFS_TX_LEAKAGE_MIN}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, +}; + +/* channel tx leakage table - ht40 */ +struct dfs_matrix_tx_leak_info ht40_chan[] = { + {52, + {{36, DFS_TX_LEAKAGE_AUTO_MIN}, {40, DFS_TX_LEAKAGE_AUTO_MIN}, + {44, 230}, {48, 230}, + {52, DFS_TX_LEAKAGE_MIN}, {56, DFS_TX_LEAKAGE_MIN}, + {60, DFS_TX_LEAKAGE_AUTO_MIN}, {64, DFS_TX_LEAKAGE_AUTO_MIN}, + {100, 625}, {104, 323}, + {108, 646}, {112, 646}, + {116, DFS_TX_LEAKAGE_MAX}, {120, DFS_TX_LEAKAGE_MAX}, + {124, DFS_TX_LEAKAGE_MAX}, {128, DFS_TX_LEAKAGE_MAX}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {56, + {{36, DFS_TX_LEAKAGE_AUTO_MIN}, {40, DFS_TX_LEAKAGE_AUTO_MIN}, + {44, DFS_TX_LEAKAGE_AUTO_MIN}, {48, DFS_TX_LEAKAGE_AUTO_MIN}, + {52, DFS_TX_LEAKAGE_MIN}, {56, DFS_TX_LEAKAGE_MIN}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, 611}, {104, 611}, + {108, 617}, {112, 617}, + {116, DFS_TX_LEAKAGE_MAX}, {120, DFS_TX_LEAKAGE_MAX}, + {124, DFS_TX_LEAKAGE_MAX}, {128, DFS_TX_LEAKAGE_MAX}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {60, + {{36, DFS_TX_LEAKAGE_AUTO_MIN}, {40, DFS_TX_LEAKAGE_AUTO_MIN}, + {44, DFS_TX_LEAKAGE_AUTO_MIN}, {48, DFS_TX_LEAKAGE_AUTO_MIN}, + {52, 190}, {56, 190}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, 608}, {104, 608}, + {108, 623}, {112, 623}, + {116, DFS_TX_LEAKAGE_MAX}, {120, DFS_TX_LEAKAGE_MAX}, + {124, DFS_TX_LEAKAGE_MAX}, {128, DFS_TX_LEAKAGE_MAX}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {64, + {{36, DFS_TX_LEAKAGE_AUTO_MIN}, {40, DFS_TX_LEAKAGE_AUTO_MIN}, + {44, DFS_TX_LEAKAGE_AUTO_MIN}, {48, DFS_TX_LEAKAGE_AUTO_MIN}, + {52, 295}, {56, 295}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, 594}, {104, 594}, + {108, 625}, {112, 625}, + {116, DFS_TX_LEAKAGE_MAX}, {120, DFS_TX_LEAKAGE_MAX}, + {124, DFS_TX_LEAKAGE_MAX}, {128, DFS_TX_LEAKAGE_MAX}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {100, + {{36, 618}, {40, 618}, + {44, 604}, {48, 604}, + {52, 596}, {56, 596}, + {60, 584}, {64, 584}, + {100, DFS_TX_LEAKAGE_MIN}, {104, DFS_TX_LEAKAGE_MIN}, + {108, 299}, {112, 299}, + {116, DFS_TX_LEAKAGE_AUTO_MIN}, {120, DFS_TX_LEAKAGE_AUTO_MIN}, + {124, DFS_TX_LEAKAGE_AUTO_MIN}, {128, DFS_TX_LEAKAGE_AUTO_MIN}, + {132, 538}, {136, 538}, + {140, 598}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {104, + {{36, 636}, {40, 636}, + {44, 601}, {48, 601}, + {52, 616}, {56, 616}, + {60, 584}, {64, 584}, + {100, DFS_TX_LEAKAGE_MIN}, {104, DFS_TX_LEAKAGE_MIN}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, DFS_TX_LEAKAGE_AUTO_MIN}, {120, DFS_TX_LEAKAGE_AUTO_MIN}, + {124, DFS_TX_LEAKAGE_AUTO_MIN}, {128, DFS_TX_LEAKAGE_AUTO_MIN}, + {132, 553}, {136, 553}, + {140, 568}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {108, + {{36, 600}, {40, 600}, + {44, 627}, {48, 627}, + {52, 611}, {56, 611}, + {60, 611}, {64, 611}, + {100, 214}, {104, 214}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, DFS_TX_LEAKAGE_AUTO_MIN}, {120, DFS_TX_LEAKAGE_AUTO_MIN}, + {124, DFS_TX_LEAKAGE_AUTO_MIN}, {128, DFS_TX_LEAKAGE_AUTO_MIN}, + {132, DFS_TX_LEAKAGE_AUTO_MIN}, {136, DFS_TX_LEAKAGE_AUTO_MIN}, + {140, 534}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {112, + {{36, 645}, {40, 645}, + {44, 641}, {48, 641}, + {52, 618}, {56, 618}, + {60, 612}, {64, 612}, + {100, 293}, {104, 293}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, DFS_TX_LEAKAGE_MIN}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_AUTO_MIN}, {128, DFS_TX_LEAKAGE_AUTO_MIN}, + {132, DFS_TX_LEAKAGE_AUTO_MIN}, {136, DFS_TX_LEAKAGE_AUTO_MIN}, + {140, 521}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {116, + {{36, 661}, {40, 661}, + {44, 624}, {48, 624}, + {52, 634}, {56, 634}, + {60, 611}, {64, 611}, + {100, DFS_TX_LEAKAGE_AUTO_MIN}, {104, DFS_TX_LEAKAGE_AUTO_MIN}, + {108, 217}, {112, 217}, + {116, DFS_TX_LEAKAGE_MIN}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_AUTO_MIN}, {128, DFS_TX_LEAKAGE_AUTO_MIN}, + {132, DFS_TX_LEAKAGE_AUTO_MIN}, {136, DFS_TX_LEAKAGE_AUTO_MIN}, + {140, DFS_TX_LEAKAGE_AUTO_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {120, + {{36, 667}, {40, 667}, + {44, 645}, {48, 645}, + {52, 633}, {56, 633}, + {60, 619}, {64, 619}, + {100, DFS_TX_LEAKAGE_AUTO_MIN}, {104, DFS_TX_LEAKAGE_AUTO_MIN}, + {108, 291}, {112, 291}, + {116, DFS_TX_LEAKAGE_MIN}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_AUTO_MIN}, {136, DFS_TX_LEAKAGE_AUTO_MIN}, + {140, DFS_TX_LEAKAGE_AUTO_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {124, + {{36, 676}, {40, 676}, + {44, 668}, {48, 668}, + {52, 595}, {56, 595}, + {60, 622}, {64, 622}, + {100, DFS_TX_LEAKAGE_AUTO_MIN}, {104, DFS_TX_LEAKAGE_AUTO_MIN}, + {108, DFS_TX_LEAKAGE_AUTO_MIN}, {112, DFS_TX_LEAKAGE_AUTO_MIN}, + {116, 225}, {120, 225}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_AUTO_MIN}, {136, DFS_TX_LEAKAGE_AUTO_MIN}, + {140, DFS_TX_LEAKAGE_AUTO_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {128, + {{36, 678}, {40, 678}, + {44, 664}, {48, 664}, + {52, 651}, {56, 651}, + {60, 643}, {64, 643}, + {100, DFS_TX_LEAKAGE_AUTO_MIN}, {104, DFS_TX_LEAKAGE_AUTO_MIN}, + {108, DFS_TX_LEAKAGE_AUTO_MIN}, {112, DFS_TX_LEAKAGE_AUTO_MIN}, + {116, 293}, {120, 293}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_AUTO_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {132, + {{36, 689}, {40, 689}, + {44, 669}, {48, 669}, + {52, 662}, {56, 662}, + {60, 609}, {64, 609}, + {100, 538}, {104, 538}, + {108, DFS_TX_LEAKAGE_AUTO_MIN}, {112, DFS_TX_LEAKAGE_AUTO_MIN}, + {116, DFS_TX_LEAKAGE_AUTO_MIN}, {120, DFS_TX_LEAKAGE_AUTO_MIN}, + {124, 247}, {128, 247}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {136, + {{36, 703}, {40, 703}, + {44, 688}, {48, DFS_TX_LEAKAGE_MIN}, + {52, 671}, {56, 671}, + {60, 658}, {64, 658}, + {100, 504}, {104, 504}, + {108, DFS_TX_LEAKAGE_AUTO_MIN}, {112, DFS_TX_LEAKAGE_AUTO_MIN}, + {116, DFS_TX_LEAKAGE_AUTO_MIN}, {120, DFS_TX_LEAKAGE_AUTO_MIN}, + {124, 289}, {128, 289}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {140, + {{36, 695}, {40, 695}, + {44, 684}, {48, 684}, + {52, 664}, {56, 664}, + {60, 658}, {64, 658}, + {100, 601}, {104, 601}, + {108, 545}, {112, 545}, + {116, DFS_TX_LEAKAGE_AUTO_MIN}, {120, DFS_TX_LEAKAGE_AUTO_MIN}, + {124, DFS_TX_LEAKAGE_AUTO_MIN}, {128, DFS_TX_LEAKAGE_AUTO_MIN}, + {132, 262}, {136, 262}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {144, + {{36, 695}, {40, 695}, + {44, 684}, {48, 684}, + {52, 664}, {56, 664}, + {60, 658}, {64, 658}, + {100, 601}, {104, 601}, + {108, 545}, {112, 545}, + {116, DFS_TX_LEAKAGE_AUTO_MIN}, {120, DFS_TX_LEAKAGE_AUTO_MIN}, + {124, DFS_TX_LEAKAGE_AUTO_MIN}, {128, DFS_TX_LEAKAGE_AUTO_MIN}, + {132, 262}, {136, 262}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, +}; + +/* channel tx leakage table - ht20 */ +struct dfs_matrix_tx_leak_info ht20_chan[] = { + {52, + {{36, DFS_TX_LEAKAGE_AUTO_MIN}, {40, 286}, + {44, 225}, {48, 121}, + {52, DFS_TX_LEAKAGE_MIN}, {56, DFS_TX_LEAKAGE_MIN}, + {60, 300}, {64, DFS_TX_LEAKAGE_AUTO_MIN}, + {100, 637}, {104, DFS_TX_LEAKAGE_MAX}, + {108, DFS_TX_LEAKAGE_MAX}, {112, DFS_TX_LEAKAGE_MAX}, + {116, DFS_TX_LEAKAGE_MAX}, {120, DFS_TX_LEAKAGE_MAX}, + {124, DFS_TX_LEAKAGE_MAX}, {128, DFS_TX_LEAKAGE_MAX}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {56, + {{36, 468}, {40, DFS_TX_LEAKAGE_AUTO_MIN}, + {44, DFS_TX_LEAKAGE_AUTO_MIN}, {48, 206}, + {52, DFS_TX_LEAKAGE_MIN}, {56, DFS_TX_LEAKAGE_MIN}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, DFS_TX_LEAKAGE_MAX}, {104, DFS_TX_LEAKAGE_MAX}, + {108, DFS_TX_LEAKAGE_MAX}, {112, DFS_TX_LEAKAGE_MAX}, + {116, DFS_TX_LEAKAGE_MAX}, {120, DFS_TX_LEAKAGE_MAX}, + {124, DFS_TX_LEAKAGE_MAX}, {128, DFS_TX_LEAKAGE_MAX}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {60, + {{36, 507}, {40, 440}, + {44, DFS_TX_LEAKAGE_AUTO_MIN}, {48, 313}, + {52, DFS_TX_LEAKAGE_MIN}, {56, DFS_TX_LEAKAGE_MIN}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, DFS_TX_LEAKAGE_MAX}, {104, DFS_TX_LEAKAGE_MAX}, + {108, DFS_TX_LEAKAGE_MAX}, {112, DFS_TX_LEAKAGE_MAX}, + {116, DFS_TX_LEAKAGE_MAX}, {120, DFS_TX_LEAKAGE_MAX}, + {124, DFS_TX_LEAKAGE_MAX}, {128, DFS_TX_LEAKAGE_MAX}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {64, + {{36, 516}, {40, 520}, + {44, 506}, {48, DFS_TX_LEAKAGE_AUTO_MIN}, + {52, 301}, {56, 258}, + {60, DFS_TX_LEAKAGE_MIN}, {64, DFS_TX_LEAKAGE_MIN}, + {100, 620}, {104, 617}, + {108, DFS_TX_LEAKAGE_MAX}, {112, DFS_TX_LEAKAGE_MAX}, + {116, DFS_TX_LEAKAGE_MAX}, {120, DFS_TX_LEAKAGE_MAX}, + {124, DFS_TX_LEAKAGE_MAX}, {128, DFS_TX_LEAKAGE_MAX}, + {132, DFS_TX_LEAKAGE_MAX}, {136, DFS_TX_LEAKAGE_MAX}, + {140, DFS_TX_LEAKAGE_MAX}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {100, + {{36, 616}, {40, 601}, + {44, 604}, {48, 589}, + {52, 612}, {56, 592}, + {60, 590}, {64, 582}, + {100, DFS_TX_LEAKAGE_MIN}, {104, 131}, + {108, DFS_TX_LEAKAGE_AUTO_MIN}, {112, DFS_TX_LEAKAGE_AUTO_MIN}, + {116, DFS_TX_LEAKAGE_AUTO_MIN}, {120, 522}, + {124, 571}, {128, 589}, + {132, 593}, {136, 598}, + {140, 594}, + {144, DFS_TX_LEAKAGE_MIN}, + } }, + + {104, + {{36, 622}, {40, 624}, + {44, 618}, {48, 610}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, DFS_TX_LEAKAGE_MIN}, {104, DFS_TX_LEAKAGE_MIN}, + {108, DFS_TX_LEAKAGE_MIN}, {112, 463}, + {116, 483}, {120, 503}, + {124, 523}, {128, 565}, + {132, 570}, {136, 588}, + {140, 585}, + {144, DFS_TX_LEAKAGE_MIN}, + } }, + + {108, + {{36, 620}, {40, 638}, + {44, 611}, {48, 614}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, 477}, {104, DFS_TX_LEAKAGE_MIN}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, 477}, {120, 497}, + {124, 517}, {128, 537}, + {132, 557}, {136, 577}, + {140, 603}, + {144, DFS_TX_LEAKAGE_MIN}, + } }, + + {112, + {{36, 636}, {40, 623}, + {44, 638}, {48, 628}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, DFS_TX_LEAKAGE_MAX}, {64, 606}, + {100, 501}, {104, 481}, + {108, DFS_TX_LEAKAGE_MIN}, {112, DFS_TX_LEAKAGE_MIN}, + {116, DFS_TX_LEAKAGE_MIN}, {120, 481}, + {124, 501}, {128, 421}, + {132, 541}, {136, 561}, + {140, 583}, + {144, DFS_TX_LEAKAGE_MIN}, + } }, + + {116, + {{36, 646}, {40, 648}, + {44, 633}, {48, 634}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, 615}, {64, 594}, + {100, 575}, {104, 554}, + {108, 534}, {112, DFS_TX_LEAKAGE_MIN}, + {116, DFS_TX_LEAKAGE_MIN}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, 534}, {136, 554}, + {140, 574}, + {144, DFS_TX_LEAKAGE_MIN}, + } }, + + {120, + {{36, 643}, {40, 649}, + {44, 654}, {48, 629}, + {52, DFS_TX_LEAKAGE_MAX}, {56, 621}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, 565}, {104, 545}, + {108, 525}, {112, 505}, + {116, DFS_TX_LEAKAGE_MIN}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, 505}, + {132, 525}, {136, 545}, + {140, 565}, + {144, DFS_TX_LEAKAGE_MIN}, + } }, + + {124, + {{36, 638}, {40, 657}, + {44, 663}, {48, 649}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, 581}, {104, 561}, + {108, 541}, {112, 521}, + {116, 499}, {120, DFS_TX_LEAKAGE_MIN}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, 499}, {136, 519}, + {140, 539}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {128, + {{36, 651}, {40, 651}, + {44, 674}, {48, 640}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, 603}, {104, 560}, + {108, 540}, {112, 520}, + {116, 499}, {120, 479}, + {124, DFS_TX_LEAKAGE_MIN}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, 479}, + {140, 499}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {132, + {{36, 643}, {40, 668}, + {44, 651}, {48, 657}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, DFS_TX_LEAKAGE_MAX}, {104, 602}, + {108, 578}, {112, 570}, + {116, 550}, {120, 530}, + {124, 510}, {128, DFS_TX_LEAKAGE_MIN}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, 490}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {136, + {{36, 654}, {40, 667}, + {44, 666}, {48, 642}, + {52, DFS_TX_LEAKAGE_MAX}, {56, DFS_TX_LEAKAGE_MAX}, + {60, DFS_TX_LEAKAGE_MAX}, {64, DFS_TX_LEAKAGE_MAX}, + {100, DFS_TX_LEAKAGE_MAX}, {104, DFS_TX_LEAKAGE_MAX}, + {108, DFS_TX_LEAKAGE_MAX}, {112, 596}, + {116, 555}, {120, 535}, + {124, 515}, {128, 495}, + {132, DFS_TX_LEAKAGE_MIN}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {140, + {{36, 679}, {40, 673}, + {44, 667}, {48, 656}, + {52, 634}, {56, 663}, + {60, 662}, {64, 660}, + {100, DFS_TX_LEAKAGE_MAX}, {104, DFS_TX_LEAKAGE_MAX}, + {108, DFS_TX_LEAKAGE_MAX}, {112, 590}, + {116, 573}, {120, 553}, + {124, 533}, {128, 513}, + {132, 490}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, + + {144, + {{36, 679}, {40, 673}, + {44, 667}, {48, 656}, + {52, 634}, {56, 663}, + {60, 662}, {64, 660}, + {100, DFS_TX_LEAKAGE_MAX}, {104, DFS_TX_LEAKAGE_MAX}, + {108, DFS_TX_LEAKAGE_MAX}, {112, 590}, + {116, 573}, {120, 553}, + {124, 533}, {128, 513}, + {132, 490}, {136, DFS_TX_LEAKAGE_MIN}, + {140, DFS_TX_LEAKAGE_MIN}, + {144, DFS_TX_LEAKAGE_MIN} + } }, +}; + +/* + * dfs_find_target_channel_in_channel_matrix() - finds the leakage matrix + * @ch_width: target channel width + * @NOL_channel: the NOL channel whose leakage matrix is required + * @pTarget_chnl_mtrx: pointer to target channel matrix returned. + * + * This function gives the leakage matrix for given NOL channel and ch_width + * + * Return: TRUE or FALSE + */ +static bool +dfs_find_target_channel_in_channel_matrix(enum phy_ch_width ch_width, + uint8_t NOL_channel, + struct dfs_tx_leak_info **pTarget_chnl_mtrx) +{ + struct dfs_tx_leak_info *target_chan_matrix = NULL; + struct dfs_matrix_tx_leak_info *pchan_matrix = NULL; + uint32_t nchan_matrix; + int i = 0; + + switch (ch_width) { + case CH_WIDTH_20MHZ: + /* HT20 */ + pchan_matrix = ht20_chan; + nchan_matrix = QDF_ARRAY_SIZE(ht20_chan); + break; + case CH_WIDTH_40MHZ: + /* HT40 */ + pchan_matrix = ht40_chan; + nchan_matrix = QDF_ARRAY_SIZE(ht40_chan); + break; + case CH_WIDTH_80MHZ: + /* HT80 */ + pchan_matrix = ht80_chan; + nchan_matrix = QDF_ARRAY_SIZE(ht80_chan); + break; + default: + /* handle exception and fall back to HT20 table */ + pchan_matrix = ht20_chan; + nchan_matrix = QDF_ARRAY_SIZE(ht20_chan); + break; + } + + for (i = 0; i < nchan_matrix; i++) { + /* find the SAP channel to map the leakage matrix */ + if (NOL_channel == pchan_matrix[i].channel) { + target_chan_matrix = pchan_matrix[i].chan_matrix; + break; + } + } + + if (NULL == target_chan_matrix) { + return false; + } else { + *pTarget_chnl_mtrx = target_chan_matrix; + return true; + } +} + +QDF_STATUS +dfs_mark_leaking_ch(struct wlan_dfs *dfs, + enum phy_ch_width ch_width, + uint8_t temp_ch_lst_sz, + uint8_t *temp_ch_lst) +{ + struct dfs_tx_leak_info *target_chan_matrix = NULL; + uint32_t num_channel = (CHAN_ENUM_144 - CHAN_ENUM_36) + 1; + uint32_t j = 0; + uint32_t k = 0; + uint8_t dfs_nol_channel; + struct dfs_nolelem *nol; + + nol = dfs->dfs_nol; + while (nol) { + dfs_nol_channel = wlan_freq_to_chan(nol->nol_freq); + if (false == dfs_find_target_channel_in_channel_matrix( + ch_width, dfs_nol_channel, + &target_chan_matrix)) { + /* + * should never happen, we should always find a table + * here, if we don't, need a fix here! + */ + dfs_err(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, + "Couldn't find target channel matrix!"); + QDF_ASSERT(0); + return QDF_STATUS_E_FAILURE; + } + /* + * following is based on assumption that both temp_ch_lst + * and target channel matrix are in increasing order of + * ch_id + */ + for (j = 0, k = 0; j < temp_ch_lst_sz && k < num_channel;) { + if (temp_ch_lst[j] == 0) { + j++; + continue; + } + if (target_chan_matrix[k].leak_chan != temp_ch_lst[j]) { + k++; + continue; + } + /* + * check leakage from candidate channel + * to NOL channel + */ + if (target_chan_matrix[k].leak_lvl <= + dfs->tx_leakage_threshold) { + /* + * candidate channel will have + * bad leakage in NOL channel, + * remove from temp list + */ + dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, + "dfs: channel: %d will have bad leakage due to channel: %d\n", + dfs_nol_channel, temp_ch_lst[j]); + temp_ch_lst[j] = 0; + } + j++; + k++; + } + nol = nol->nol_next; + } /* end of loop that selects each NOL */ + + return QDF_STATUS_SUCCESS; +} +#else +QDF_STATUS +dfs_mark_leaking_ch(struct wlan_dfs *dfs, + enum phy_ch_width ch_width, + uint8_t temp_ch_lst_sz, + uint8_t *temp_ch_lst) +{ + return QDF_STATUS_SUCCESS; +} +#endif /** * dfs_populate_80mhz_available_channels()- Populate channels for 80MHz using @@ -567,10 +1396,14 @@ uint8_t dfs_prepare_random_channel(struct wlan_dfs *dfs, uint8_t dfs_region, struct dfs_acs_info *acs_info) { + int i = 0; + uint8_t final_cnt = 0; uint8_t target_ch = 0; uint8_t *random_chan_list = NULL; uint32_t random_chan_cnt = 0; uint16_t flag_no_weather = 0; + uint8_t *leakage_adjusted_lst; + uint8_t final_lst[NUM_CHANNELS] = {0}; if (!ch_list || !ch_cnt) { dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, @@ -601,16 +1434,48 @@ uint8_t dfs_prepare_random_channel(struct wlan_dfs *dfs, flag_no_weather = (dfs_region == DFS_ETSI_REGION_VAL) ? flags & DFS_RANDOM_CH_FLAG_NO_WEATHER_CH : 0; + /* list adjusted after leakage has been marked */ + leakage_adjusted_lst = qdf_mem_malloc(random_chan_cnt); + if (!leakage_adjusted_lst) { + dfs_alert(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, + "Memory allocation failed"); + qdf_mem_free(random_chan_list); + return 0; + } + do { + qdf_mem_copy(leakage_adjusted_lst, random_chan_list, + random_chan_cnt); + if (QDF_IS_STATUS_ERROR(dfs_mark_leaking_ch(dfs, *ch_wd, + random_chan_cnt, + leakage_adjusted_lst))) { + qdf_mem_free(random_chan_list); + qdf_mem_free(leakage_adjusted_lst); + return 0; + } + if (*ch_wd == DFS_CH_WIDTH_20MHZ) { + /* + * PASS: 3 - from leakage_adjusted_lst, prepare valid + * ch list and use random number from that + */ + for (i = 0; i < random_chan_cnt; i++) { + if (leakage_adjusted_lst[i] == 0) + continue; + dfs_debug(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, + "dfs: Channel=%d added to available list", + leakage_adjusted_lst[i]); + final_lst[final_cnt] = leakage_adjusted_lst[i]; + final_cnt++; + } target_ch = dfs_get_rand_from_lst( - dfs, random_chan_list, random_chan_cnt); + dfs, final_lst, final_cnt); break; } target_ch = dfs_find_ch_with_fallback(dfs, ch_wd, &cur_chan->dfs_ch_vhtop_ch_freq_seg2, - random_chan_list, + leakage_adjusted_lst, random_chan_cnt); /* @@ -633,6 +1498,7 @@ uint8_t dfs_prepare_random_channel(struct wlan_dfs *dfs, } while (true); qdf_mem_free(random_chan_list); + qdf_mem_free(leakage_adjusted_lst); dfs_info(dfs, WLAN_DEBUG_DFS_RANDOM_CHAN, "target_ch = %d", target_ch); return target_ch; diff --git a/umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h b/umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h index 4a6fdc54a6e3..e44ffe6d100c 100644 --- a/umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h +++ b/umac/dfs/dispatcher/inc/wlan_dfs_tgt_api.h @@ -158,6 +158,18 @@ QDF_STATUS tgt_dfs_destroy_object(struct wlan_objmgr_pdev *pdev); QDF_STATUS tgt_dfs_radar_enable(struct wlan_objmgr_pdev *pdev, int no_cac, uint32_t opmode); +#ifdef QCA_MCL_DFS_SUPPORT +/** + * tgt_dfs_set_tx_leakage_threshold() - set tx_leakage_threshold. + * @pdev: Pointer to DFS pdev object. + * @tx_leakage_threshold: tx leakage threshold for dfs. + * + * Return QDF_STATUS. + */ +QDF_STATUS tgt_dfs_set_tx_leakage_threshold(struct wlan_objmgr_pdev *pdev, + uint16_t tx_leakage_threshold); +#endif + /** * tgt_dfs_control()- Used to process ioctls related to DFS. * @pdev: Pointer to DFS pdev object. diff --git a/umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h b/umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h index 134dcdcf691c..e36b7aa4b5f2 100644 --- a/umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h +++ b/umac/dfs/dispatcher/inc/wlan_dfs_utils_api.h @@ -416,6 +416,26 @@ QDF_STATUS utils_dfs_update_cur_chan_flags(struct wlan_objmgr_pdev *pdev, uint64_t flags, uint16_t flagext); +#ifdef QCA_MCL_DFS_SUPPORT +/** + * utils_dfs_mark_leaking_ch() - to mark channel leaking in to nol + * @pdev: Pointer to pdev structure. + * @ch_width: channel width + * @temp_ch_lst_sz: the target channel list + * @temp_ch_lst: the target channel list + * + * This function removes the channels from temp channel list that + * (if selected as target channel) will cause leakage in one of + * the NOL channels + * + * Return: QDF_STATUS + */ +QDF_STATUS utils_dfs_mark_leaking_ch(struct wlan_objmgr_pdev *pdev, + enum phy_ch_width ch_width, + uint8_t temp_ch_lst_sz, + uint8_t *temp_ch_lst); +#endif + /** * utils_get_dfsdomain() - Get DFS domain. * @pdev: Pointer to PDEV structure. diff --git a/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c b/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c index b4967ef29dca..6fa8cff25f6e 100644 --- a/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c +++ b/umac/dfs/dispatcher/src/wlan_dfs_tgt_api.c @@ -223,6 +223,25 @@ QDF_STATUS tgt_dfs_destroy_object(struct wlan_objmgr_pdev *pdev) } EXPORT_SYMBOL(tgt_dfs_destroy_object); +#ifdef QCA_MCL_DFS_SUPPORT +QDF_STATUS tgt_dfs_set_tx_leakage_threshold(struct wlan_objmgr_pdev *pdev, + uint16_t tx_leakage_threshold) +{ + struct wlan_dfs *dfs; + + dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); + if (!dfs) { + dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "dfs is NULL"); + return QDF_STATUS_E_FAILURE; + } + + dfs->tx_leakage_threshold = tx_leakage_threshold; + + return QDF_STATUS_SUCCESS; +} +EXPORT_SYMBOL(tgt_dfs_set_tx_leakage_threshold); +#endif + QDF_STATUS tgt_dfs_control(struct wlan_objmgr_pdev *pdev, u_int id, void *indata, diff --git a/umac/dfs/dispatcher/src/wlan_dfs_utils_api.c b/umac/dfs/dispatcher/src/wlan_dfs_utils_api.c index d9982e30ef76..659dd2dd7952 100644 --- a/umac/dfs/dispatcher/src/wlan_dfs_utils_api.c +++ b/umac/dfs/dispatcher/src/wlan_dfs_utils_api.c @@ -852,6 +852,25 @@ uint32_t utils_dfs_chan_to_freq(uint8_t chan) } EXPORT_SYMBOL(utils_dfs_chan_to_freq); +#ifdef QCA_MCL_DFS_SUPPORT +QDF_STATUS utils_dfs_mark_leaking_ch(struct wlan_objmgr_pdev *pdev, + enum phy_ch_width ch_width, + uint8_t temp_ch_lst_sz, + uint8_t *temp_ch_lst) +{ + struct wlan_dfs *dfs = NULL; + + dfs = global_dfs_to_mlme.pdev_get_comp_private_obj(pdev); + if (!dfs) { + dfs_err(dfs, WLAN_DEBUG_DFS_ALWAYS, "null dfs"); + return QDF_STATUS_E_FAILURE; + } + + return dfs_mark_leaking_ch(dfs, ch_width, temp_ch_lst_sz, temp_ch_lst); +} +EXPORT_SYMBOL(utils_dfs_mark_leaking_ch); +#endif + int utils_get_dfsdomain(struct wlan_objmgr_pdev *pdev) { enum dfs_reg dfsdomain;