1 /* 2 * Copyright (c) 2013, 2016-2018 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2005-2006 Atheros Communications, Inc. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 18 /** 19 * DOC: This file has main dfs structures. 20 */ 21 22 #ifndef _DFS_H_ 23 #define _DFS_H_ 24 25 #include <qdf_types.h> /* QDF_NBUF_EXEMPT_NO_EXEMPTION, etc. */ 26 #include <qdf_net_types.h> /* QDF_NBUF_EXEMPT_NO_EXEMPTION, etc. */ 27 #include <qdf_nbuf.h> /* qdf_nbuf_t, etc. */ 28 #include <qdf_util.h> /* qdf_assert */ 29 #include <qdf_lock.h> /* qdf_spinlock */ 30 #include <qdf_time.h> 31 #include <qdf_timer.h> 32 33 #include <wlan_dfs_ioctl.h> 34 #include "dfs_structs.h" 35 #include "dfs_channel.h" 36 #include "dfs_ioctl_private.h" 37 #include <i_qdf_types.h> /* For qdf_packed*/ 38 #include <queue.h> /* For STAILQ_ENTRY */ 39 #include <wlan_objmgr_psoc_obj.h> 40 #include <wlan_objmgr_pdev_obj.h> 41 #include <osdep.h> 42 43 /* File Line and Submodule String */ 44 #define FLSM(x, str) #str " : " FL(x) 45 /* Cast to dfs type */ 46 #define DC(x) ((struct wlan_dfs *)(x)) 47 48 /** 49 * dfs_log: dfs logging using submodule MASKs and 50 * QDF trace level. 51 * The logging is controlled by two bitmasks: 52 * 1) submodule bitmask: sm 53 * 2) trace level masks: level 54 * 55 * @dfs: The dfs object pointer or NULL if dfs is not defined. 56 * @sm: Submodule BITMASK. 57 * @level: QDF trace level. 58 * @args...: Variable argument list. 59 * 60 * The submodule(sm) cannot be empty even if argument dfs is NULL. 61 * Else the macro will create a compilation error. 62 * One may provide WLAN_DEBUG_DFS_ALWAYS when the argument dfs is NULL. 63 * Example:- 64 * dfs_log(NULL, WLAN_DEBUG_DFS_ALWAYS, QDF_TRACE_LEVEL_INFO,"Error pulse"); 65 * 66 * Why DC(x) is required? 67 * Since NULL is defined as ((void *)(0)), if the argument "dfs" 68 * in a call to the macro "dfs_log" is NULL 69 * then during compilation (NULL)->dfs_debug_mask will dereference 70 * a (void *) type, which is illegal. Therefore, we need 71 * the cast: (DC(dfs))->dfs_debug_mask. 72 * Example:- 73 * dfs_log(NULL, WLAN_DEBUG_DFS, QDF_TRACE_LEVEL_INFO,"dfs is NULL"); 74 */ 75 #define dfs_log(dfs, sm, level, args...) do { \ 76 if (((dfs) == NULL) || \ 77 ((sm) == WLAN_DEBUG_DFS_ALWAYS) || \ 78 ((sm) & ((DC(dfs))->dfs_debug_mask))) { \ 79 QDF_TRACE(QDF_MODULE_ID_DFS, level, ## args); \ 80 } \ 81 } while (0) 82 83 #define dfs_logfl(dfs, level, sm, format, args...) \ 84 dfs_log(dfs, sm, level, FLSM(format, sm), ## args) 85 86 #define dfs_alert(dfs, sm, format, args...) \ 87 dfs_logfl(dfs, QDF_TRACE_LEVEL_FATAL, sm, format, ## args) 88 89 #define dfs_err(dfs, sm, format, args...) \ 90 dfs_logfl(dfs, QDF_TRACE_LEVEL_ERROR, sm, format, ## args) 91 92 #define dfs_warn(dfs, sm, format, args...) \ 93 dfs_logfl(dfs, QDF_TRACE_LEVEL_WARN, sm, format, ## args) 94 95 #define dfs_info(dfs, sm, format, args...) \ 96 dfs_logfl(dfs, QDF_TRACE_LEVEL_INFO, sm, format, ## args) 97 98 #define dfs_debug(dfs, sm, format, args...) \ 99 dfs_logfl(dfs, QDF_TRACE_LEVEL_DEBUG, sm, format, ## args) 100 101 #define DFS_MIN(a, b) ((a) < (b)?(a):(b)) 102 #define DFS_MAX(a, b) ((a) > (b)?(a) : (b)) 103 #define DFS_DIFF(a, b)(DFS_MAX(a, b) - DFS_MIN(a, b)) 104 105 /** 106 * Maximum number of radar events to be processed in a single iteration. 107 * Allows soft watchdog to run. 108 */ 109 #define MAX_EVENTS 100 110 111 /** 112 * Constants to use for chirping detection. 113 * 114 * All are unconverted as HW reports them. 115 * 116 * XXX Are these constants with or without fast clock 5GHz operation? 117 * XXX Peregrine reports pulses in microseconds, not hardware clocks! 118 */ 119 120 #define MAX_DUR_FOR_LOW_RSSI 4 121 122 /** 123 * Cascade has issue with reported duration especially when there is a 124 * crossover of chirp from one segment to another. It may report a value 125 * of duration that is well below 50us for a valid FCC type 5 chirping 126 * pulse. For now changing minimum duration as a work around. This will 127 * affect all chips but since we detect chirp with Merlin+, we may be OK 128 * for now. We need a more robust solution for this. 129 */ 130 #define MIN_BIN5_DUR_CAS 25 /* 50 * 1.25*/ 131 #define MIN_BIN5_DUR_MICROSEC_CAS 20 132 #define MIN_BIN5_DUR 63 /* 50 * 1.25*/ 133 #define MIN_BIN5_DUR_MICROSEC 50 134 #define MAYBE_BIN5_DUR 35 /* 28 * 1.25*/ 135 #define MAYBE_BIN5_DUR_MICROSEC 28 136 137 /* Conversion is already done using dfs->dur_multiplier */ 138 #define MAX_BIN5_DUR 145 /* use 145 for osprey */ 139 #define MAX_BIN5_DUR_MICROSEC 105 140 141 #define DFS_MARGIN_EQUAL(a, b, margin) ((DFS_DIFF(a, b)) <= margin) 142 #define DFS_MAX_STAGGERED_BURSTS 3 143 144 /** 145 * All filter thresholds in the radar filter tables are effective at a 50% 146 * channel loading. 147 */ 148 #define DFS_CHAN_LOADING_THRESH 50 149 #define DFS_EXT_CHAN_LOADING_THRESH 30 150 #define DFS_DEFAULT_PRI_MARGIN 6 151 #define DFS_DEFAULT_FIXEDPATTERN_PRI_MARGIN 4 152 153 #define WLAN_DFSQ_LOCK(_dfs) qdf_spin_lock_bh(&(_dfs)->dfs_radarqlock) 154 #define WLAN_DFSQ_UNLOCK(_dfs) qdf_spin_unlock_bh(&(_dfs)->dfs_radarqlock) 155 #define WLAN_DFSQ_LOCK_CREATE(_dfs) qdf_spinlock_create( \ 156 &(_dfs)->dfs_radarqlock) 157 #define WLAN_DFSQ_LOCK_DESTROY(_dfs) qdf_spinlock_destroy( \ 158 &(_dfs)->dfs_radarqlock) 159 160 #define WLAN_ARQ_LOCK(_dfs) qdf_spin_lock_bh(&(_dfs)->dfs_arqlock) 161 #define WLAN_ARQ_UNLOCK(_dfs) qdf_spin_unlock_bh(&(_dfs)->dfs_arqlock) 162 #define WLAN_ARQ_LOCK_CREATE(_dfs) qdf_spinlock_create(&(_dfs)->dfs_arqlock) 163 #define WLAN_ARQ_LOCK_DESTROY(_dfs) qdf_spinlock_destroy(&(_dfs)->dfs_arqlock) 164 165 #define WLAN_DFSEVENTQ_LOCK(_dfs) qdf_spin_lock_bh(&(_dfs)->dfs_eventqlock) 166 #define WLAN_DFSEVENTQ_UNLOCK(_dfs) qdf_spin_unlock_bh( \ 167 &(_dfs)->dfs_eventqlock) 168 #define WLAN_DFSEVENTQ_LOCK_CREATE(_dfs) qdf_spinlock_create( \ 169 &(_dfs)->dfs_eventqlock) 170 #define WLAN_DFSEVENTQ_LOCK_DESTROY(_dfs) qdf_spinlock_destroy( \ 171 &(_dfs)->dfs_eventqlock) 172 173 #define WLAN_DFSNOL_LOCK(_dfs) qdf_spin_lock_bh(&(_dfs)->dfs_nol_lock) 174 #define WLAN_DFSNOL_UNLOCK(_dfs) qdf_spin_unlock_bh(&(_dfs)->dfs_nol_lock) 175 #define WLAN_DFSNOL_LOCK_CREATE(_dfs) qdf_spinlock_create( \ 176 &(_dfs)->dfs_nol_lock) 177 #define WLAN_DFSNOL_LOCK_DESTROY(_dfs) qdf_spinlock_destroy( \ 178 &(_dfs)->dfs_nol_lock) 179 180 #define PRECAC_LIST_LOCK(_dfs) qdf_spin_lock_irqsave( \ 181 &(_dfs)->dfs_precac_lock) 182 #define PRECAC_LIST_UNLOCK(_dfs) qdf_spin_unlock_irqrestore( \ 183 &(_dfs)->dfs_precac_lock) 184 #define PRECAC_LIST_LOCK_CREATE(_dfs) qdf_spinlock_create( \ 185 &(_dfs)->dfs_precac_lock) 186 #define PRECAC_LIST_LOCK_DESTROY(_dfs) qdf_spinlock_destroy( \ 187 &(_dfs)->dfs_precac_lock) 188 189 /* Mask for time stamp from descriptor */ 190 #define DFS_TSMASK 0xFFFFFFFF 191 /* Shift for time stamp from descriptor */ 192 #define DFS_TSSHIFT 32 193 /* 64 bit TSF wrap value */ 194 #define DFS_TSF_WRAP 0xFFFFFFFFFFFFFFFFULL 195 /* TS mask for 64 bit value */ 196 #define DFS_64BIT_TSFMASK 0x0000000000007FFFULL 197 198 #define DFS_AR_RADAR_RSSI_THR 5 /* in dB */ 199 #define DFS_AR_RADAR_RESET_INT 1 /* in secs */ 200 #define DFS_AR_RADAR_MAX_HISTORY 500 201 #define DFS_AR_REGION_WIDTH 128 202 #define DFS_AR_RSSI_THRESH_STRONG_PKTS 17 /* in dB */ 203 #define DFS_AR_RSSI_DOUBLE_THRESHOLD 15 /* in dB */ 204 #define DFS_AR_MAX_NUM_ACK_REGIONS 9 205 #define DFS_AR_ACK_DETECT_PAR_THRESH 20 206 #define DFS_AR_PKT_COUNT_THRESH 20 207 208 #define DFS_MAX_DL_SIZE 64 209 #define DFS_MAX_DL_MASK 0x3F 210 211 #define DFS_NOL_TIME DFS_NOL_TIMEOUT_US 212 /* 30 minutes in usecs */ 213 214 #define DFS_WAIT_TIME (60*1000000) /* 1 minute in usecs */ 215 216 #define DFS_DISABLE_TIME (3*60*1000000) /* 3 minutes in usecs */ 217 218 #define DFS_MAX_B5_SIZE 128 219 #define DFS_MAX_B5_MASK 0x0000007F /* 128 */ 220 221 /* Max number of overlapping filters */ 222 #define DFS_MAX_RADAR_OVERLAP 16 223 224 /* Max number of dfs events which can be q'd */ 225 #define DFS_MAX_EVENTS 1024 226 227 #define DFS_RADAR_EN 0x80000000 /* Radar detect is capable */ 228 #define DFS_AR_EN 0x40000000 /* AR detect is capable */ 229 /* Radar detect in second segment is capable */ 230 #define DFS_SECOND_SEGMENT_RADAR_EN 0x20000000 231 #define DFS_MAX_RSSI_VALUE 0x7fffffff /* Max rssi value */ 232 233 #define DFS_BIN_MAX_PULSES 60 /* max num of pulses in a burst */ 234 #define DFS_BIN5_PRI_LOWER_LIMIT 990 /* us */ 235 236 /** 237 * To cover the single pusle burst case, change from 2010 us to 238 * 2010000 us. 239 */ 240 241 /** 242 * This is reverted back to 2010 as larger value causes false 243 * bin5 detect (EV76432, EV76320) 244 */ 245 #define DFS_BIN5_PRI_HIGHER_LIMIT 2010 /* us */ 246 247 #define DFS_BIN5_WIDTH_MARGIN 4 /* us */ 248 #define DFS_BIN5_RSSI_MARGIN 5 /* dBm */ 249 250 /** 251 * Following threshold is not specified but should be 252 * okay statistically. 253 */ 254 #define DFS_BIN5_BRI_LOWER_LIMIT 300000 /* us */ 255 #define DFS_BIN5_BRI_UPPER_LIMIT 12000000 /* us */ 256 257 /* Max number of pulses kept in buffer */ 258 #define DFS_MAX_PULSE_BUFFER_SIZE 1024 259 #define DFS_MAX_PULSE_BUFFER_MASK 0x3ff 260 261 #define DFS_FAST_CLOCK_MULTIPLIER (800/11) 262 #define DFS_NO_FAST_CLOCK_MULTIPLIER (80) 263 #define DFS_BIG_SIDX 10000 264 265 /** 266 * Software use: channel interference used for as AR as well as RADAR 267 * interference detection. 268 */ 269 #define CHANNEL_INTERFERENCE 0x01 270 271 #define CHANNEL_2GHZ 0x00080 /* 2 GHz spectrum channel. */ 272 #define CHANNEL_OFDM 0x00040 /* OFDM channel */ 273 #define CHANNEL_TURBO 0x00010 /* Turbo Channel */ 274 #define CHANNEL_108G (CHANNEL_2GHZ|CHANNEL_OFDM|CHANNEL_TURBO) 275 276 /* qdf_packed - denotes structure is packed. */ 277 #define qdf_packed __qdf_packed 278 279 #define SEG_ID_PRIMARY 0 280 #define SEG_ID_SECONDARY 1 281 282 /* MIN and MAX width for different regions */ 283 #define REG0_MIN_WIDTH 33 284 #define REG0_MAX_WIDTH 38 285 #define REG1_MIN_WIDTH 39 286 #define REG1_MAX_WIDTH 44 287 #define REG2_MIN_WIDTH 53 288 #define REG2_MAX_WIDTH 58 289 #define REG3_MIN_WIDTH 126 290 #define REG3_MAX_WIDTH 140 291 #define REG4_MIN_WIDTH 141 292 #define REG4_MAX_WIDTH 160 293 #define REG5_MIN_WIDTH 189 294 #define REG5_MAX_WIDTH 210 295 #define REG6_MIN_WIDTH 360 296 #define REG6_MAX_WIDTH 380 297 #define REG7_MIN_WIDTH 257 298 #define REG7_MAX_WIDTH 270 299 #define REG8_MIN_WIDTH 295 300 #define REG8_MAX_WIDTH 302 301 302 #define OVER_SAMPLING_FREQ 44000 303 #define SAMPLING_FREQ 40000 304 #define HUNDRED 100 305 #define NUM_BINS 128 306 #define THOUSAND 1000 307 308 /* Check if the dfs current channel is 5.8GHz */ 309 #define DFS_CURCHAN_IS_58GHz(freq) \ 310 ((((freq) >= 5745) && ((freq) <= 5865)) ? true : false) 311 312 /* ETSI11_WORLD regdmn pair id */ 313 #define ETSI11_WORLD_REGDMN_PAIR_ID 0x26 314 #define ETSI12_WORLD_REGDMN_PAIR_ID 0x28 315 #define ETSI13_WORLD_REGDMN_PAIR_ID 0x27 316 #define ETSI14_WORLD_REGDMN_PAIR_ID 0x29 317 318 /* Array offset to ETSI legacy pulse */ 319 #define ETSI_LEGACY_PULSE_ARR_OFFSET 2 320 321 #define DFS_NOL_ADD_CHAN_LOCKED(dfs, freq, timeout) \ 322 do { \ 323 WLAN_DFSNOL_LOCK(dfs); \ 324 dfs_nol_addchan(dfs, freq, timeout); \ 325 WLAN_DFSNOL_UNLOCK(dfs); \ 326 } while (0) 327 328 #define DFS_NOL_DELETE_CHAN_LOCKED(dfs, freq, chwidth) \ 329 do { \ 330 WLAN_DFSNOL_LOCK(dfs); \ 331 dfs_nol_delete(dfs, freq, chwidth); \ 332 WLAN_DFSNOL_UNLOCK(dfs); \ 333 } while (0) 334 335 #define DFS_GET_NOL_LOCKED(dfs, dfs_nol, nchan) \ 336 do { \ 337 WLAN_DFSNOL_LOCK(dfs); \ 338 dfs_get_nol(dfs, dfs_nol, nchan); \ 339 WLAN_DFSNOL_UNLOCK(dfs); \ 340 } while (0) 341 342 #define DFS_PRINT_NOL_LOCKED(dfs) \ 343 do { \ 344 WLAN_DFSNOL_LOCK(dfs); \ 345 dfs_print_nol(dfs); \ 346 WLAN_DFSNOL_UNLOCK(dfs); \ 347 } while (0) 348 349 #define DFS_NOL_FREE_LIST_LOCKED(dfs) \ 350 do { \ 351 WLAN_DFSNOL_LOCK(dfs); \ 352 dfs_nol_free_list(dfs); \ 353 WLAN_DFSNOL_UNLOCK(dfs); \ 354 } while (0) 355 356 /** 357 * struct dfs_pulseparams - DFS pulse param structure. 358 * @p_time: Time for start of pulse in usecs. 359 * @p_dur: Duration of pulse in usecs. 360 * @p_rssi: RSSI of pulse. 361 * @p_seg_id: Segment id. 362 * @p_sidx: Sidx value. 363 * @p_delta_peak: Delta peak value. 364 * @p_seq_num: Sequence number. 365 */ 366 struct dfs_pulseparams { 367 uint64_t p_time; 368 uint8_t p_dur; 369 uint8_t p_rssi; 370 uint8_t p_seg_id; 371 int16_t p_sidx; 372 int8_t p_delta_peak; 373 uint32_t p_seq_num; 374 } qdf_packed; 375 376 /** 377 * struct dfs_pulseline - Pulseline structure. 378 * @pl_elems[]: array of pulses in delay line. 379 * @pl_firstelem: Index of the first element. 380 * @pl_lastelem: Index of the last element. 381 * @pl_numelems: Number of elements in the delay line. 382 */ 383 struct dfs_pulseline { 384 struct dfs_pulseparams pl_elems[DFS_MAX_PULSE_BUFFER_SIZE]; 385 uint32_t pl_firstelem; 386 uint32_t pl_lastelem; 387 uint32_t pl_numelems; 388 } qdf_packed; 389 390 #define DFS_EVENT_CHECKCHIRP 0x01 /* Whether to check the chirp flag */ 391 #define DFS_EVENT_HW_CHIRP 0x02 /* hardware chirp */ 392 #define DFS_EVENT_SW_CHIRP 0x04 /* software chirp */ 393 394 /* Use this only if the event has CHECKCHIRP set. */ 395 #define DFS_EVENT_ISCHIRP(e) \ 396 ((e)->re_flags & (DFS_EVENT_HW_CHIRP | DFS_EVENT_SW_CHIRP)) 397 398 /** 399 * Check if the given event is to be rejected as not possibly 400 * a chirp. This means: 401 * (a) it's a hardware or software checked chirp, and 402 * (b) the HW/SW chirp bits are both 0. 403 */ 404 #define DFS_EVENT_NOTCHIRP(e) \ 405 (((e)->re_flags & (DFS_EVENT_CHECKCHIRP)) && (!DFS_EVENT_ISCHIRP((e)))) 406 407 /** 408 * struct dfs_event - DFS event structure. 409 * @re_full_ts: 64-bit full timestamp from interrupt time. 410 * @re_ts: Original 15 bit recv timestamp. 411 * @re_rssi: Rssi of radar event. 412 * @re_dur: Duration of radar pulse. 413 * @re_chanindex: Channel of event. 414 * @re_flags: Event flags. 415 * @re_freq: Centre frequency of event, KHz. 416 * @re_freq_lo: Lower bounds of frequency, KHz. 417 * @re_freq_hi: Upper bounds of frequency, KHz. 418 * @re_seg_id: HT80_80/HT160 use. 419 * @re_sidx: Seg index. 420 * @re_freq_offset_khz: Freq offset in KHz 421 * @re_peak_mag: Peak mag. 422 * @re_total_gain: Total gain. 423 * @re_mb_gain: Mb gain. 424 * @re_relpwr_db: Relpower in db. 425 * @re_delta_diff: Delta diff. 426 * @re_delta_peak: Delta peak. 427 * @re_list: List of radar events. 428 */ 429 struct dfs_event { 430 uint64_t re_full_ts; 431 uint32_t re_ts; 432 uint8_t re_rssi; 433 uint8_t re_dur; 434 uint8_t re_chanindex; 435 uint8_t re_flags; 436 uint32_t re_freq; 437 uint32_t re_freq_lo; 438 uint32_t re_freq_hi; 439 uint8_t re_seg_id; 440 int re_sidx; 441 u_int re_freq_offset_khz; 442 int re_peak_mag; 443 int re_total_gain; 444 int re_mb_gain; 445 int re_relpwr_db; 446 uint8_t re_delta_diff; 447 int8_t re_delta_peak; 448 449 STAILQ_ENTRY(dfs_event) re_list; 450 } qdf_packed; 451 452 #define DFS_AR_MAX_ACK_RADAR_DUR 511 453 #define DFS_AR_MAX_NUM_PEAKS 3 454 #define DFS_AR_ARQ_SIZE 2048 /* 8K AR events for buffer size */ 455 #define DFS_AR_ARQ_SEQSIZE 2049 /* Sequence counter wrap for AR */ 456 457 #define DFS_RADARQ_SIZE 512 /* 1K radar events for buffer size */ 458 #define DFS_RADARQ_SEQSIZE 513 /* Sequence counter wrap for radar */ 459 /* Number of radar channels we keep state for */ 460 #define DFS_NUM_RADAR_STATES 64 461 /* Max number radar filters for each type */ 462 #define DFS_MAX_NUM_RADAR_FILTERS 10 463 /* Number of different radar types */ 464 #define DFS_MAX_RADAR_TYPES 32 465 /* Number of filter index table rows */ 466 #define DFS_NUM_FT_IDX_TBL_ROWS 256 467 468 /* RADAR filter pattern type 1*/ 469 #define WLAN_DFS_RF_PATTERN_TYPE_1 1 470 471 /** 472 * struct dfs_ar_state - DFS AR state structure. 473 * @ar_prevwidth: Previous width. 474 * @ar_phyerrcount[]: Phy error count. 475 * @ar_acksum: Acksum. 476 * @ar_packetthreshold: Thresh to determine traffic load. 477 * @ar_parthreshold: Thresh to determine peak. 478 * @ar_radarrssi: Rssi threshold for AR event. 479 * @ar_prevtimestamp: Prev time stamp. 480 * @ar_peaklist[]: Peak list. 481 */ 482 struct dfs_ar_state { 483 uint32_t ar_prevwidth; 484 uint32_t ar_phyerrcount[DFS_AR_MAX_ACK_RADAR_DUR]; 485 uint32_t ar_acksum; 486 uint32_t ar_packetthreshold; 487 uint32_t ar_parthreshold; 488 uint32_t ar_radarrssi; 489 uint16_t ar_prevtimestamp; 490 uint16_t ar_peaklist[DFS_AR_MAX_NUM_PEAKS]; 491 }; 492 493 /** 494 * struct dfs_delayelem - Delay Element. 495 * @de_time: Current "filter" time for start of pulse in usecs. 496 * @de_dur: Duration of pulse in usecs. 497 * @de_rssi: Rssi of pulse in dB. 498 * @de_ts: Time stamp for this delay element. 499 * @de_seg_id: Segment id for HT80_80/HT160 use. 500 * @de_sidx: Sidx value. 501 * @de_delta_peak: Delta peak. 502 * @de_seq_num: Sequence number. 503 */ 504 struct dfs_delayelem { 505 uint32_t de_time; 506 uint8_t de_dur; 507 uint8_t de_rssi; 508 uint64_t de_ts; 509 uint8_t de_seg_id; 510 int16_t de_sidx; 511 int8_t de_delta_peak; 512 uint32_t de_seq_num; 513 } qdf_packed; 514 515 /** 516 * struct dfs_delayline - DFS Delay Line. 517 * @dl_elems[]: Array of pulses in delay line. 518 * @dl_last_ts: Last timestamp the delay line was used (in usecs). 519 * @dl_firstelem: Index of the first element. 520 * @dl_lastelem: Index of the last element. 521 * @dl_numelems: Number of elements in the delay line. 522 * The following is to handle fractional PRI pulses that can cause false 523 * detection. 524 * @dl_seq_num_start: Sequence number of first pulse that was part of 525 * threshold match. 526 * @dl_seq_num_stop: Sequence number of last pulse that was part of threshold 527 * match. 528 * The following is required because the first pulse may or may not be in the 529 * delay line but we will find it iin the pulse line using dl_seq_num_second's 530 * diff_ts value. 531 * @dl_seq_num_second: Sequence number of second pulse that was part of 532 * threshold match. 533 * @dl_search_pri: We need final search PRI to identify possible fractional 534 * PRI issue. 535 * @dl_min_sidx: Minimum sidx value of pulses used to match thershold. 536 * Used for sidx spread check. 537 * @dl_max_sidx: Maximum sidx value of pulses used to match thershold. 538 * Used for sidx spread check. 539 * @dl_delta_peak_match_count: Number of pulse in the delay line that had valid 540 * delta peak value. 541 */ 542 struct dfs_delayline { 543 struct dfs_delayelem dl_elems[DFS_MAX_DL_SIZE]; 544 uint64_t dl_last_ts; 545 uint32_t dl_firstelem; 546 uint32_t dl_lastelem; 547 uint32_t dl_numelems; 548 uint32_t dl_seq_num_start; 549 uint32_t dl_seq_num_stop; 550 uint32_t dl_seq_num_second; 551 uint32_t dl_search_pri; 552 int16_t dl_min_sidx; 553 int8_t dl_max_sidx; 554 uint8_t dl_delta_peak_match_count; 555 } qdf_packed; 556 557 /** 558 * struct dfs_filter - Dfs filter. 559 * @rf_dl: Delay line of pulses for this filter. 560 * @rf_numpulses: Number of pulses in the filter. 561 * @rf_minpri: Min pri to be considered for this filter. 562 * @rf_maxpri: Max pri to be considered for this filter. 563 * @rf_threshold: Match filter output threshold for radar detect. 564 * @rf_filterlen: Length (in usecs) of the filter. 565 * @rf_patterntype: Fixed or variable pattern type. 566 * @rf_fixed_pri_radar_pulse: indicates if it is a fixed pri pulse. 567 * @rf_mindur: Min duration for this radar filter. 568 * @rf_maxdur: Max duration for this radar filter. 569 * @rf_ignore_pri_window: Ignore pri window. 570 * @rf_pulseid: Unique ID corresponding to the original filter ID. 571 * To reduce false detection, look at frequency spread. For now we will use 572 * sidx spread. But for HT160 frequency spread will be a better measure. 573 * @rf_sidx_spread: Maximum SIDX value spread in a matched sequence 574 * excluding FCC Bin 5. 575 * @rf_check_delta_peak: Minimum allowed delta_peak value for a pulse to be 576 * considetred for this filter's match. 577 */ 578 struct dfs_filter { 579 struct dfs_delayline rf_dl; 580 uint32_t rf_numpulses; 581 uint32_t rf_minpri; 582 uint32_t rf_maxpri; 583 uint32_t rf_threshold; 584 uint32_t rf_filterlen; 585 uint32_t rf_patterntype; 586 uint32_t rf_fixed_pri_radar_pulse; 587 uint32_t rf_mindur; 588 uint32_t rf_maxdur; 589 uint32_t rf_ignore_pri_window; 590 uint32_t rf_pulseid; 591 uint16_t rf_sidx_spread; 592 int8_t rf_check_delta_peak; 593 } qdf_packed; 594 595 /** 596 * struct dfs_filtertype - DFS Filter type. 597 * @ft_filterdur[]: Filter array. 598 * @ft_filterdur: Duration of pulse which specifies filter type. 599 * @ft_numfilters: Num filters of this type. 600 * @ft_last_ts: Last timestamp this filtertype was used (in usecs). 601 * @ft_mindur: Min pulse duration to be considered for this filter type. 602 * @ft_maxdur: Max pulse duration to be considered for this filter type. 603 * @ft_rssithresh: Min rssi to be considered for this filter type. 604 * @ft_numpulses: Num pulses in each filter of this type. 605 * @ft_patterntype: Fixed or variable pattern type. 606 * @ft_minpri: Min pri to be considered for this type. 607 * @ft_rssimargin: Rssi threshold margin. In Turbo Mode HW reports rssi 3dB 608 * lower than in non TURBO mode. This will offset that diff. 609 */ 610 struct dfs_filtertype { 611 struct dfs_filter ft_filters[DFS_MAX_NUM_RADAR_FILTERS]; 612 uint32_t ft_filterdur; 613 uint32_t ft_numfilters; 614 uint64_t ft_last_ts; 615 uint32_t ft_mindur; 616 uint32_t ft_maxdur; 617 uint32_t ft_rssithresh; 618 uint32_t ft_numpulses; 619 uint32_t ft_patterntype; 620 uint32_t ft_minpri; 621 uint32_t ft_rssimargin; 622 }; 623 624 /** 625 * struct dfs_channel - Channel structure for dfs component. 626 * @dfs_ch_freq: Frequency in Mhz. 627 * @dfs_ch_flags: Channel flags. 628 * @dfs_ch_flagext: Extended channel flags. 629 * @dfs_ch_ieee: IEEE channel number. 630 * @dfs_ch_vhtop_ch_freq_seg1: Channel Center frequency. 631 * @dfs_ch_vhtop_ch_freq_seg2: Channel Center frequency applicable for 80+80MHz 632 * mode of operation. 633 */ 634 struct dfs_channel { 635 uint16_t dfs_ch_freq; 636 uint64_t dfs_ch_flags; 637 uint16_t dfs_ch_flagext; 638 uint8_t dfs_ch_ieee; 639 uint8_t dfs_ch_vhtop_ch_freq_seg1; 640 uint8_t dfs_ch_vhtop_ch_freq_seg2; 641 }; 642 643 /** 644 * struct dfs_state - DFS state. 645 * @rs_chan: Channel info. 646 * @rs_chanindex: Channel index in radar structure. 647 * @rs_numradarevents: Number of radar events. 648 * @rs_param: Phy param. 649 */ 650 struct dfs_state { 651 struct dfs_channel rs_chan; 652 uint8_t rs_chanindex; 653 uint32_t rs_numradarevents; 654 struct wlan_dfs_phyerr_param rs_param; 655 }; 656 657 #define DFS_NOL_TIMEOUT_S (30*60) /* 30 minutes in seconds */ 658 #define DFS_NOL_TIMEOUT_MS (DFS_NOL_TIMEOUT_S * 1000) 659 #define DFS_NOL_TIMEOUT_US (DFS_NOL_TIMEOUT_MS * 1000) 660 661 /** 662 * struct dfs_nolelem - DFS NOL element. 663 * @nol_dfs Back pointer to dfs object. 664 * @nol_freq: Centre frequency. 665 * @nol_chwidth: Event width (MHz). 666 * @nol_start_ticks: NOL start time in OS ticks. 667 * @nol_timeout_ms: NOL timeout value in msec. 668 * @nol_timer: Per element NOL timer. 669 * @nol_next: Next element pointer. 670 */ 671 struct dfs_nolelem { 672 TAILQ_ENTRY(dfs_nolelem) nolelem_list; 673 struct wlan_dfs *nol_dfs; 674 uint32_t nol_freq; 675 uint32_t nol_chwidth; 676 unsigned long nol_start_ticks; 677 uint32_t nol_timeout_ms; 678 os_timer_t nol_timer; 679 struct dfs_nolelem *nol_next; 680 } qdf_packed; 681 682 683 /** 684 * struct dfs_info - DFS Info. 685 * @rn_ftindex: Number of different types of radars. 686 * @rn_lastfull_ts: Last 64 bit timstamp from recv interrupt. 687 * @rn_last_ts: last 15 bit ts from recv descriptor. 688 * @rn_last_unique_ts: last unique 32 bit ts from recv descriptor. 689 * @rn_ts_prefix: Prefix to prepend to 15 bit recv ts. 690 * @rn_numbin5radars: Number of bin5 radar pulses to search for. 691 * @rn_fastdivGCval: Value of fast diversity gc limit from init file. 692 * @rn_minrssithresh: Min rssi for all radar types. 693 * @rn_maxpulsedur: Max pulse width in TSF ticks. 694 * @dfs_ext_chan_busy: Ext chan busy. 695 * @ext_chan_busy_ts: Ext chan busy time. 696 * @dfs_bin5_chirp_ts: Ext bin5 chrip time. 697 * @dfs_last_bin5_dur: Last bin5 during. 698 */ 699 struct dfs_info { 700 uint32_t rn_ftindex; 701 uint64_t rn_lastfull_ts; 702 uint16_t rn_last_ts; 703 uint32_t rn_last_unique_ts; 704 uint64_t rn_ts_prefix; 705 uint32_t rn_numbin5radars; 706 uint32_t rn_fastdivGCval; 707 int32_t rn_minrssithresh; 708 uint32_t rn_maxpulsedur; 709 uint8_t dfs_ext_chan_busy; 710 uint64_t ext_chan_busy_ts; 711 uint64_t dfs_bin5_chirp_ts; 712 uint8_t dfs_last_bin5_dur; 713 } qdf_packed; 714 715 /** 716 * struct dfs_bin5elem - BIN5 elements. 717 * @be_ts: Timestamp for the bin5 element. 718 * @be_rssi: Rssi for the bin5 element. 719 * @be_dur: Duration of bin5 element. 720 */ 721 struct dfs_bin5elem { 722 uint64_t be_ts; 723 uint32_t be_rssi; 724 uint32_t be_dur; 725 }; 726 727 /** 728 * struct dfs_bin5radars - BIN5 radars. 729 * @br_elems[]: List of bin5 elems that fall within the time window. 730 * @br_firstelem: Index of the first element. 731 * @br_lastelem: Index of the last element. 732 * @br_numelems: Number of elements in the delay line. 733 * @br_pulse: Original info about bin5 pulse. 734 */ 735 struct dfs_bin5radars { 736 struct dfs_bin5elem br_elems[DFS_MAX_B5_SIZE]; 737 uint32_t br_firstelem; 738 uint32_t br_lastelem; 739 uint32_t br_numelems; 740 struct dfs_bin5pulse br_pulse; 741 }; 742 743 /** 744 * struct dfs_stats - DFS stats. 745 * @num_radar_detects: Total num. of radar detects. 746 * @num_seg_two_radar_detects: Total num. of radar detected in secondary segment 747 * @total_phy_errors: Total PHY errors. 748 * @owl_phy_errors: OWL PHY errors. 749 * @pri_phy_errors: Primary channel phy errors. 750 * @ext_phy_errors: Extension channel phy errors. 751 * @dc_phy_errors: DC PHY errors. 752 * @early_ext_phy_errors: Extension channel early radar found error. 753 * @bwinfo_errors: Bogus bandwidth info received in descriptor. 754 * @datalen_discards: data length at least three bytes of payload. 755 * @rssi_discards: RSSI is not accurate. 756 * @last_reset_tstamp: Last reset timestamp. 757 */ 758 struct dfs_stats { 759 uint32_t num_radar_detects; 760 uint32_t num_seg_two_radar_detects; 761 uint32_t total_phy_errors; 762 uint32_t owl_phy_errors; 763 uint32_t pri_phy_errors; 764 uint32_t ext_phy_errors; 765 uint32_t dc_phy_errors; 766 uint32_t early_ext_phy_errors; 767 uint32_t bwinfo_errors; 768 uint32_t datalen_discards; 769 uint32_t rssi_discards; 770 uint64_t last_reset_tstamp; 771 }; 772 773 #define DFS_EVENT_LOG_SIZE 256 774 775 /** 776 * struct dfs_event_log - DFS event log. 777 * @ts: 64-bit full timestamp from interrupt time. 778 * @diff_ts: Diff timestamp. 779 * @rssi: Rssi of radar event. 780 * @dur: Duration of radar pulse. 781 * @is_chirp: Chirp flag. 782 * @seg_id: HT80_80/HT160 use. 783 * @sidx: Seg index. 784 * @freq_offset_khz: Freq offset in KHz 785 * @peak_mag: Peak mag. 786 * @total_gain: Total gain. 787 * @mb_gain: Mb gain. 788 * @relpwr_db: Relpower in db. 789 * @delta_diff: Delta diff. 790 * @delta_peak: Delta peak. 791 */ 792 793 struct dfs_event_log { 794 uint64_t ts; 795 uint32_t diff_ts; 796 uint8_t rssi; 797 uint8_t dur; 798 int is_chirp; 799 uint8_t seg_id; 800 int sidx; 801 u_int freq_offset_khz; 802 int peak_mag; 803 int total_gain; 804 int mb_gain; 805 int relpwr_db; 806 uint8_t delta_diff; 807 int8_t delta_peak; 808 }; 809 810 #define WLAN_DFS_RESET_TIME_S 7 811 #define WLAN_DFS_WAIT (60 + WLAN_DFS_RESET_TIME_S) /* 60 seconds */ 812 #define WLAN_DFS_WAIT_MS ((WLAN_DFS_WAIT) * 1000) /*in MS*/ 813 814 #define WLAN_DFS_WEATHER_CHANNEL_WAIT_MIN 10 /*10 minutes*/ 815 #define WLAN_DFS_WEATHER_CHANNEL_WAIT_S (WLAN_DFS_WEATHER_CHANNEL_WAIT_MIN * 60) 816 #define WLAN_DFS_WEATHER_CHANNEL_WAIT_MS \ 817 ((WLAN_DFS_WEATHER_CHANNEL_WAIT_S) * 1000) /*in MS*/ 818 819 #define WLAN_DFS_WAIT_POLL_PERIOD 2 /* 2 seconds */ 820 #define WLAN_DFS_WAIT_POLL_PERIOD_MS \ 821 ((WLAN_DFS_WAIT_POLL_PERIOD) * 1000) /*in MS*/ 822 823 #define DFS_DEBUG_TIMEOUT_S 30 /* debug timeout is 30 seconds */ 824 #define DFS_DEBUG_TIMEOUT_MS (DFS_DEBUG_TIMEOUT_S * 1000) 825 826 #define RSSI_POSSIBLY_FALSE 50 827 #define SEARCH_FFT_REPORT_PEAK_MAG_THRSH 40 828 829 /** 830 * struct wlan_dfs - The main dfs structure. 831 * @dfs_debug_mask: Current debug bitmask. 832 * @dfs_curchan_radindex: Current channel radar index. 833 * @dfs_extchan_radindex: Extension channel radar index. 834 * @dfsdomain: Current DFS domain. 835 * @dfs_proc_phyerr: Flags for Phy Errs to process. 836 * @dfs_eventq: Q of free dfs event objects. 837 * @dfs_eventqlock: Lock for free dfs event list. 838 * @dfs_radarq: Q of radar events. 839 * @dfs_radarqlock: Lock for dfs q. 840 * @dfs_arq: Q of AR events. 841 * @dfs_arqlock: Lock for AR q. 842 * @dfs_ar_state: AR state. 843 * @dfs_radar[]: Per-Channel Radar detector state. 844 * @dfs_radarf[]: One filter for each radar pulse type. 845 * @dfs_rinfo: State vars for radar processing. 846 * @dfs_b5radars: Array of bin5 radar events. 847 * @dfs_ftindextable: Map of radar durs to filter types. 848 * @dfs_nol: Non occupancy list for radar. 849 * @dfs_nol_count: How many items? 850 * @dfs_defaultparams: Default phy params per radar state. 851 * @wlan_dfs_stats: DFS related stats. 852 * @pulses: Pulse history. 853 * @events: Events structure. 854 * @wlan_radar_tasksched: Radar task is scheduled. 855 * @wlan_dfswait: Waiting on channel for radar detect. 856 * @wlan_dfstest: Test timer in progress. 857 * @dfs_caps: Object of wlan_dfs_caps structure. 858 * @wlan_dfstest_ieeechan: IEEE chan num to return to after a dfs mute 859 * test. 860 * @wlan_dfs_cac_time: CAC period. 861 * @wlan_dfstesttime: Time to stay off chan during dfs test. 862 * @wlan_dfswaittimer: Dfs wait timer. 863 * @wlan_dfstesttimer: Dfs mute test timer. 864 * @wlan_dfs_debug_timer: Dfs debug timer. 865 * @dfs_second_segment_bangradar: Bangaradar on second segment of 866 * VHT80_80/160. 867 * @is_radar_found_on_secondary_seg: Radar on second segment. 868 * @is_radar_during_precac: Radar found during precac. 869 * @dfs_precac_lock: Lock to protect precac lists. 870 * @dfs_precac_enable: Enable the precac. 871 * @dfs_precac_secondary_freq: Second segment freq for precac. 872 * @dfs_precac_primary_freq: Primary freq. 873 * @dfs_precac_timer_running: Precac timer running. 874 * @dfs_defer_precac_channel_change: Defer precac channel change. 875 * @dfs_pre_cac_timeout_channel_change: Channel change due to precac timeout. 876 * @wlan_dfs_task_timer: Dfs wait timer. 877 * @dur_multiplier: Duration multiplier. 878 * @wlan_dfs_isdfsregdomain: True when AP is in DFS domain 879 * @wlan_dfs_false_rssi_thres: False RSSI Threshold. 880 * @wlan_dfs_peak_mag: Peak mag. 881 * @radar_log[]: Radar log. 882 * @dfs_event_log_count: Event log count. 883 * @dfs_event_log_on: Event log on. 884 * @dfs_phyerr_count: Same as number of PHY radar interrupts. 885 * @dfs_phyerr_reject_count: When TLV is supported, # of radar events 886 * ignored after TLV is parsed. 887 * @dfs_phyerr_queued_count: Number of radar events queued for matching 888 * the filters. 889 * @dfs_phyerr_freq_min: Phyerr min freq. 890 * @dfs_phyerr_freq_max: Phyerr max freq. 891 * @dfs_phyerr_w53_counter: Phyerr w53 counter. 892 * @dfs_pri_multiplier: Allow pulse if they are within multiple of 893 * PRI for the radar type. 894 * @wlan_dfs_nol_timeout: NOL timeout. 895 * @update_nol: Update NOL. 896 * @dfs_seq_num: Sequence number. 897 * @dfs_nol_event[]: NOL event. 898 * @dfs_nol_timer: NOL list processing. 899 * @dfs_nol_free_list: NOL free list. 900 * @dfs_nol_elem_free_work: The work queue to free an NOL element. 901 * @dfs_cac_timer: CAC timer. 902 * @dfs_cac_valid_timer: Ignore CAC when this timer is running. 903 * @dfs_cac_timeout_override: Overridden cac timeout. 904 * @dfs_enable: DFS Enable. 905 * @dfs_cac_timer_running: DFS CAC timer running. 906 * @dfs_ignore_dfs: Ignore DFS. 907 * @dfs_ignore_cac: Ignore CAC. 908 * @dfs_cac_valid: DFS CAC valid. 909 * @dfs_cac_valid_time: Time for which CAC will be valid and will 910 * not be re-done. 911 * @dfs_precac_timer: PRECAC timer. 912 * @dfs_precac_timeout_override: Overridden precac timeout. 913 * @dfs_num_precac_freqs: Number of PreCAC VHT80 frequencies. 914 * @dfs_precac_required_list: PreCAC required list. 915 * @dfs_precac_done_list: PreCAC done list. 916 * @dfs_precac_nol_list: PreCAC NOL List. 917 * @dfs_is_offload_enabled: Set if DFS offload enabled. 918 * @dfs_use_nol: Use the NOL when radar found(default: TRUE) 919 * @dfs_nol_lock: Lock to protect nol list. 920 * @tx_leakage_threshold: Tx leakage threshold for dfs. 921 * @dfs_use_nol_subchannel_marking: Use subchannel marking logic to add only 922 * radar affected subchannel instead of all 923 * bonding channels. 924 */ 925 struct wlan_dfs { 926 uint32_t dfs_debug_mask; 927 int16_t dfs_curchan_radindex; 928 int16_t dfs_extchan_radindex; 929 uint32_t dfsdomain; 930 uint32_t dfs_proc_phyerr; 931 932 STAILQ_HEAD(, dfs_event) dfs_eventq; 933 qdf_spinlock_t dfs_eventqlock; 934 935 STAILQ_HEAD(, dfs_event) dfs_radarq; 936 qdf_spinlock_t dfs_radarqlock; 937 938 STAILQ_HEAD(, dfs_event) dfs_arq; 939 qdf_spinlock_t dfs_arqlock; 940 941 struct dfs_ar_state dfs_ar_state; 942 struct dfs_state dfs_radar[DFS_NUM_RADAR_STATES]; 943 struct dfs_filtertype *dfs_radarf[DFS_MAX_RADAR_TYPES]; 944 struct dfs_info dfs_rinfo; 945 struct dfs_bin5radars *dfs_b5radars; 946 int8_t **dfs_ftindextable; 947 struct dfs_nolelem *dfs_nol; 948 int dfs_nol_count; 949 struct wlan_dfs_phyerr_param dfs_defaultparams; 950 struct dfs_stats wlan_dfs_stats; 951 struct dfs_pulseline *pulses; 952 struct dfs_event *events; 953 954 uint32_t wlan_radar_tasksched:1, 955 wlan_dfswait:1, 956 wlan_dfstest:1; 957 struct wlan_dfs_caps dfs_caps; 958 uint8_t wlan_dfstest_ieeechan; 959 uint32_t wlan_dfs_cac_time; 960 uint32_t wlan_dfstesttime; 961 os_timer_t wlan_dfswaittimer; 962 os_timer_t wlan_dfstesttimer; 963 os_timer_t wlan_dfs_debug_timer; 964 uint8_t dfs_bangradar; 965 bool dfs_second_segment_bangradar; 966 bool is_radar_found_on_secondary_seg; 967 bool is_radar_during_precac; 968 qdf_spinlock_t dfs_precac_lock; 969 bool dfs_precac_enable; 970 uint8_t dfs_precac_secondary_freq; 971 uint8_t dfs_precac_primary_freq; 972 uint8_t dfs_precac_timer_running; 973 uint8_t dfs_defer_precac_channel_change; 974 uint8_t dfs_pre_cac_timeout_channel_change:1; 975 os_timer_t wlan_dfs_task_timer; 976 int dur_multiplier; 977 uint16_t wlan_dfs_isdfsregdomain; 978 int wlan_dfs_false_rssi_thres; 979 int wlan_dfs_peak_mag; 980 struct dfs_event_log radar_log[DFS_EVENT_LOG_SIZE]; 981 int dfs_event_log_count; 982 int dfs_event_log_on; 983 int dfs_phyerr_count; 984 int dfs_phyerr_reject_count; 985 int dfs_phyerr_queued_count; 986 int dfs_phyerr_freq_min; 987 int dfs_phyerr_freq_max; 988 int dfs_phyerr_w53_counter; 989 int dfs_pri_multiplier; 990 int wlan_dfs_nol_timeout; 991 bool update_nol; 992 uint32_t dfs_seq_num; 993 int dfs_nol_event[DFS_CHAN_MAX]; 994 os_timer_t dfs_nol_timer; 995 996 TAILQ_HEAD(, dfs_nolelem) dfs_nol_free_list; 997 qdf_work_t dfs_nol_elem_free_work; 998 999 os_timer_t dfs_cac_timer; 1000 os_timer_t dfs_cac_valid_timer; 1001 int dfs_cac_timeout_override; 1002 uint8_t dfs_enable:1, 1003 dfs_cac_timer_running:1, 1004 dfs_ignore_dfs:1, 1005 dfs_ignore_cac:1, 1006 dfs_cac_valid:1; 1007 uint32_t dfs_cac_valid_time; 1008 os_timer_t dfs_precac_timer; 1009 int dfs_precac_timeout_override; 1010 uint8_t dfs_num_precac_freqs; 1011 1012 TAILQ_HEAD(, dfs_precac_entry) dfs_precac_required_list; 1013 TAILQ_HEAD(, dfs_precac_entry) dfs_precac_done_list; 1014 TAILQ_HEAD(, dfs_precac_entry) dfs_precac_nol_list; 1015 1016 struct dfs_channel *dfs_curchan; 1017 struct wlan_objmgr_pdev *dfs_pdev_obj; 1018 bool dfs_is_offload_enabled; 1019 int dfs_use_nol; 1020 qdf_spinlock_t dfs_nol_lock; 1021 uint16_t tx_leakage_threshold; 1022 bool dfs_use_nol_subchannel_marking; 1023 }; 1024 1025 /** 1026 * struct dfs_soc_priv_obj - dfs private data 1027 * @psoc: pointer to PSOC object information 1028 * @pdev: pointer to PDEV object information 1029 * @dfs_is_phyerr_filter_offload: For some chip like Rome indicates too many 1030 * phyerr packets in a short time, which causes 1031 * OS hang. If this feild is configured as true, 1032 * FW will do the pre-check, filter out some 1033 * kinds of invalid phyerrors and indicate 1034 * radar detection related information to host. 1035 */ 1036 struct dfs_soc_priv_obj { 1037 struct wlan_objmgr_psoc *psoc; 1038 struct wlan_objmgr_pdev *pdev; 1039 bool dfs_is_phyerr_filter_offload; 1040 }; 1041 1042 /** 1043 * enum DFS debug - This should match the table from if_ath.c. 1044 * @WLAN_DEBUG_DFS: Minimal DFS debug. 1045 * @WLAN_DEBUG_DFS1: Normal DFS debug. 1046 * @WLAN_DEBUG_DFS2: Maximal DFS debug. 1047 * @WLAN_DEBUG_DFS3: Matched filterID display. 1048 * @WLAN_DEBUG_DFS_PHYERR: Phy error parsing. 1049 * @WLAN_DEBUG_DFS_NOL: NOL related entries. 1050 * @WLAN_DEBUG_DFS_PHYERR_SUM: PHY error summary. 1051 * @WLAN_DEBUG_DFS_PHYERR_PKT: PHY error payload. 1052 * @WLAN_DEBUG_DFS_BIN5: BIN5 checks. 1053 * @WLAN_DEBUG_DFS_BIN5_FFT: BIN5 FFT check. 1054 * @WLAN_DEBUG_DFS_BIN5_PULSE: BIN5 pulse check. 1055 * @WLAN_DEBUG_DFS_FALSE_DET: False detection debug related prints. 1056 * @WLAN_DEBUG_DFS_FALSE_DET2: Second level check to confirm poisitive 1057 * detection. 1058 * @WLAN_DEBUG_DFS_RANDOM_CHAN: Random channel selection. 1059 */ 1060 enum { 1061 WLAN_DEBUG_DFS = 0x00000100, 1062 WLAN_DEBUG_DFS1 = 0x00000200, 1063 WLAN_DEBUG_DFS2 = 0x00000400, 1064 WLAN_DEBUG_DFS3 = 0x00000800, 1065 WLAN_DEBUG_DFS_PHYERR = 0x00001000, 1066 WLAN_DEBUG_DFS_NOL = 0x00002000, 1067 WLAN_DEBUG_DFS_PHYERR_SUM = 0x00004000, 1068 WLAN_DEBUG_DFS_PHYERR_PKT = 0x00008000, 1069 WLAN_DEBUG_DFS_BIN5 = 0x00010000, 1070 WLAN_DEBUG_DFS_BIN5_FFT = 0x00020000, 1071 WLAN_DEBUG_DFS_BIN5_PULSE = 0x00040000, 1072 WLAN_DEBUG_DFS_FALSE_DET = 0x00080000, 1073 WLAN_DEBUG_DFS_FALSE_DET2 = 0x00100000, 1074 WLAN_DEBUG_DFS_RANDOM_CHAN = 0x00200000, 1075 WLAN_DEBUG_DFS_MAX = 0x80000000, 1076 WLAN_DEBUG_DFS_ALWAYS = WLAN_DEBUG_DFS_MAX 1077 }; 1078 1079 /** 1080 * struct dfs_phy_err - DFS phy error. 1081 * @fulltsf: 64-bit TSF as read from MAC. 1082 * @is_pri: Detected on primary channel. 1083 * @is_ext: Detected on extension channel. 1084 * @is_dc: Detected at DC. 1085 * @is_early: Early detect. 1086 * @do_check_chirp: Whether to check hw_chirp/sw_chirp. 1087 * @is_hw_chirp: Hardware-detected chirp. 1088 * @is_sw_chirp: Software detected chirp. 1089 * @rs_tstamp: 32 bit TSF from RX descriptor (event). 1090 * @freq: Centre frequency of event - KHz. 1091 * @freq_lo: Lower bounds of frequency - KHz. 1092 * @freq_hi: Upper bounds of frequency - KHz. 1093 * @rssi: Pulse RSSI. 1094 * @dur: Pulse duration, raw (not uS). 1095 * @seg_id: HT80_80/HT160 use. 1096 * @sidx: Seg index. 1097 * @freq_offset_khz: Freq offset in KHz. 1098 * @peak_mag: Peak mag. 1099 * @total_gain: Total gain. 1100 * @mb_gain: Mb gain. 1101 * @relpwr_db: Relpower in DB. 1102 * @pulse_delta_diff: Pulse delta diff. 1103 * @pulse_delta_peak: Pulse delta peak. 1104 * 1105 * Chirp notes! 1106 * 1107 * Pre-Sowl chips don't do FFT reports, so chirp pulses simply show up 1108 * as long duration pulses. 1109 * 1110 * The bin5 checking code would simply look for a chirp pulse of the correct 1111 * duration (within MIN_BIN5_DUR and MAX_BIN5_DUR) and add it to the "chirp" 1112 * pattern. 1113 * 1114 * For Sowl and later, an FFT was done on longer duration frames. If those 1115 * frames looked like a chirp, their duration was adjusted to fall within 1116 * the chirp duration limits. If the pulse failed the chirp test (it had 1117 * no FFT data or the FFT didn't meet the chirping requirements) then the 1118 * pulse duration was adjusted to be greater than MAX_BIN5_DUR, so it 1119 * would always fail chirp detection. 1120 * 1121 * This is pretty horrible. 1122 * 1123 * The eventual goal for chirp handling is thus: 1124 * 1125 * 1)In case someone ever wants to do chirp detection with this code on 1126 * chips that don't support chirp detection, you can still do it based 1127 * on pulse duration. That's your problem to solve. 1128 * 1129 * 2)For chips that do hardware chirp detection or FFT, the "do_check_chirp" 1130 * bit should be set. 1131 * 1132 * 3)Then, either is_hw_chirp or is_sw_chirp is set, indicating that 1133 * the hardware or software post-processing of the chirp event found 1134 * that indeed it was a chirp. 1135 * 1136 * 4)Finally, the bin5 code should just check whether the chirp bits are 1137 * set and behave appropriately, falling back onto the duration checks 1138 * if someone wishes to use this on older hardware (or with disabled 1139 * FFTs, for whatever reason.) 1140 * 1141 * XXX TODO: 1142 * 1143 * 1)add duration in uS and raw duration, so the PHY error parsing 1144 * code is responsible for doing the duration calculation; 1145 * 2)add ts in raw and corrected, so the PHY error parsing 1146 * code is responsible for doing the offsetting, not the radar 1147 * event code. 1148 */ 1149 struct dfs_phy_err { 1150 uint64_t fulltsf; 1151 uint32_t is_pri:1, 1152 is_ext:1, 1153 is_dc:1, 1154 is_early:1, 1155 do_check_chirp:1, 1156 is_hw_chirp:1, 1157 is_sw_chirp:1; 1158 uint32_t rs_tstamp; 1159 uint32_t freq; 1160 uint32_t freq_lo; 1161 uint32_t freq_hi; 1162 uint8_t rssi; 1163 uint8_t dur; 1164 uint8_t seg_id; 1165 int sidx; 1166 u_int freq_offset_khz; 1167 int peak_mag; 1168 int total_gain; 1169 int mb_gain; 1170 int relpwr_db; 1171 uint8_t pulse_delta_diff; 1172 int8_t pulse_delta_peak; 1173 }; 1174 1175 /** 1176 * struct rx_radar_status - Parsed radar status 1177 * @raw_tsf: Raw tsf 1178 * @tsf_offset: TSF offset. 1179 * @rssi: RSSI. 1180 * @pulse_duration: Pulse duration. 1181 * @is_chirp: Is chirp. 1182 * @delta_peak: Delta peak. 1183 * @delta_diff: Delta diff. 1184 * @sidx: Starting frequency. 1185 * @freq_offset: Frequency offset. 1186 * @agc_total_gain: AGC total gain. 1187 * @agc_mb_gain: AGC MB gain. 1188 */ 1189 struct rx_radar_status { 1190 uint32_t raw_tsf; 1191 uint32_t tsf_offset; 1192 int rssi; 1193 int pulse_duration; 1194 int is_chirp:1; 1195 int delta_peak; 1196 int delta_diff; 1197 int sidx; 1198 int freq_offset; /* in KHz */ 1199 int agc_total_gain; 1200 int agc_mb_gain; 1201 }; 1202 1203 /** 1204 * struct rx_search_fft_report - FFT report. 1205 * @total_gain_db: Total gain in Db. 1206 * @base_pwr_db: Base power in Db. 1207 * @fft_chn_idx: FFT channel index. 1208 * @peak_sidx: Peak sidx. 1209 * @relpwr_db: Real power in Db. 1210 * @avgpwr_db: Average power in Db. 1211 * @peak_mag: Peak Mag. 1212 * @num_str_bins_ib: Num dtr BINs IB 1213 * @seg_id: Segment ID 1214 */ 1215 struct rx_search_fft_report { 1216 uint32_t total_gain_db; 1217 uint32_t base_pwr_db; 1218 int fft_chn_idx; 1219 int peak_sidx; 1220 int relpwr_db; 1221 int avgpwr_db; 1222 int peak_mag; 1223 int num_str_bins_ib; 1224 int seg_id; 1225 }; 1226 1227 /** 1228 * dfs_process_radarevent() - process the radar event generated for a pulse. 1229 * @dfs: Pointer to wlan_dfs structure. 1230 * @chan: Current channel. 1231 * 1232 * There is currently no way to specify that a radar event has occurred on 1233 * a specific channel, so the current methodology is to mark both the pri 1234 * and ext channels as being unavailable. This should be fixed for 802.11ac 1235 * or we'll quickly run out of valid channels to use. 1236 * 1237 * If Radar found, this marks the channel (and the extension channel, if HT40) 1238 * as having seen a radar event. It marks CHAN_INTERFERENCE and will add it to 1239 * the local NOL implementation. This is only done for 'usenol=1', as the other 1240 * two modes don't do radar notification or CAC/CSA/NOL; it just notes there 1241 * was a radar. 1242 */ 1243 void dfs_process_radarevent(struct wlan_dfs *dfs, 1244 struct dfs_channel *chan); 1245 1246 /** 1247 * dfs_nol_addchan() - Add channel to NOL. 1248 * @dfs: Pointer to wlan_dfs structure. 1249 * @freq: frequency to add to NOL. 1250 * @dfs_nol_timeout: NOL timeout. 1251 */ 1252 void dfs_nol_addchan(struct wlan_dfs *dfs, 1253 uint16_t freq, 1254 uint32_t dfs_nol_timeout); 1255 1256 /** 1257 * dfs_get_nol() - Get NOL. 1258 * @dfs: Pointer to wlan_dfs structure. 1259 * @dfs_nol: Pointer to dfsreq_nolelem structure to save the channels from NOL. 1260 * @nchan: Number of channels. 1261 */ 1262 void dfs_get_nol(struct wlan_dfs *dfs, 1263 struct dfsreq_nolelem *dfs_nol, 1264 int *nchan); 1265 1266 /** 1267 * dfs_set_nol() - Set NOL. 1268 * @dfs: Pointer to wlan_dfs structure. 1269 * @dfs_nol: Pointer to dfsreq_nolelem structure. 1270 * @nchan: Number of channels. 1271 */ 1272 void dfs_set_nol(struct wlan_dfs *dfs, 1273 struct dfsreq_nolelem *dfs_nol, 1274 int nchan); 1275 1276 /** 1277 * dfs_nol_update() - NOL update 1278 * @dfs: Pointer to wlan_dfs structure. 1279 * 1280 * Notify the driver/umac that it should update the channel radar/NOL flags 1281 * based on the current NOL list. 1282 */ 1283 void dfs_nol_update(struct wlan_dfs *dfs); 1284 1285 /** 1286 * dfs_nol_timer_cleanup() - NOL timer cleanup. 1287 * @dfs: Pointer to wlan_dfs structure. 1288 * 1289 * Cancels the NOL timer and frees the NOL elements. 1290 */ 1291 void dfs_nol_timer_cleanup(struct wlan_dfs *dfs); 1292 1293 /** 1294 * dfs_nol_workqueue_cleanup() - Flushes NOL workqueue. 1295 * @dfs: Pointer to wlan_dfs structure. 1296 * 1297 * Flushes the NOL workqueue. 1298 */ 1299 void dfs_nol_workqueue_cleanup(struct wlan_dfs *dfs); 1300 1301 /** 1302 * dfs_retain_bin5_burst_pattern() - Retain the BIN5 burst pattern. 1303 * @dfs: Pointer to wlan_dfs structure. 1304 * @diff_ts: Timestamp diff. 1305 * @old_dur: Old duration. 1306 */ 1307 uint8_t dfs_retain_bin5_burst_pattern(struct wlan_dfs *dfs, 1308 uint32_t diff_ts, 1309 uint8_t old_dur); 1310 1311 /** 1312 * dfs_bin5_check_pulse() - BIN5 check pulse. 1313 * @dfs: Pointer to wlan_dfs structure. 1314 * @re: Pointer to dfs_event structure. 1315 * @br: Pointer to dfs_bin5radars structure. 1316 * 1317 * Reject the pulse if: 1318 * 1) It's outside the RSSI threshold; 1319 * 2) It's outside the pulse duration; 1320 * 3) It's been verified by HW/SW chirp checking 1321 * and neither of those found a chirp. 1322 */ 1323 int dfs_bin5_check_pulse(struct wlan_dfs *dfs, 1324 struct dfs_event *re, 1325 struct dfs_bin5radars *br); 1326 1327 /** 1328 * dfs_bin5_addpulse() - BIN5 add pulse. 1329 * @dfs: Pointer to wlan_dfs structure. 1330 * @br: Pointer to dfs_bin5radars structure. 1331 * @re: Pointer to dfs_event structure. 1332 * @thists: Timestamp. 1333 */ 1334 int dfs_bin5_addpulse(struct wlan_dfs *dfs, 1335 struct dfs_bin5radars *br, 1336 struct dfs_event *re, 1337 uint64_t thists); 1338 1339 /** 1340 * dfs_bin5_check() - BIN5 check. 1341 * @dfs: Pointer to wlan_dfs structure. 1342 * 1343 * If the dfs structure is NULL (which should be illegal if everyting is working 1344 * properly, then signify that a bin5 radar was found. 1345 */ 1346 int dfs_bin5_check(struct wlan_dfs *dfs); 1347 1348 /** 1349 * dfs_check_chirping() - Check chirping. 1350 * @dfs: Pointer to wlan_dfs structure. 1351 * @buf: Phyerr buffer 1352 * @datalen: Phyerr buf length 1353 * @is_ctl: detected on primary channel. 1354 * @is_ext: detected on extension channel. 1355 * @slope: Slope 1356 * @is_dc: DC found 1357 * 1358 * This examines the FFT data contained in the PHY error information to figure 1359 * out whether the pulse is moving across frequencies. 1360 */ 1361 int dfs_check_chirping(struct wlan_dfs *dfs, 1362 void *buf, 1363 uint16_t datalen, 1364 int is_ctl, 1365 int is_ext, 1366 int *slope, 1367 int *is_dc); 1368 1369 /** 1370 * dfs_get_random_bin5_dur() - Get random BIN5 duration. 1371 * @dfs: Pointer to wlan_dfs structure. 1372 * @tstamp: Timestamp. 1373 * 1374 * Chirping pulses may get cut off at DC and report lower durations. 1375 * This function will compute a suitable random duration for each pulse. 1376 * Duration must be between 50 and 100 us, but remember that in 1377 * wlan_process_phyerr() which calls this function, we are dealing with the 1378 * HW reported duration (unconverted). dfs_process_radarevent() will 1379 * actually convert the duration into the correct value. 1380 * This function doesn't take into account whether the hardware 1381 * is operating in 5GHz fast clock mode or not. 1382 * And this function doesn't take into account whether the hardware 1383 * is peregrine or not. 1384 */ 1385 int dfs_get_random_bin5_dur(struct wlan_dfs *dfs, 1386 uint64_t tstamp); 1387 1388 /** 1389 * dfs_print_delayline() - Prints delayline. 1390 * @dfs: Pointer to wlan_dfs structure. 1391 * @dl: Pointer to dfs_delayline structure. 1392 */ 1393 void dfs_print_delayline(struct wlan_dfs *dfs, 1394 struct dfs_delayline *dl); 1395 1396 /** 1397 * dfs_print_nol() - Print NOL elements. 1398 * @dfs: Pointer to wlan_dfs structure. 1399 */ 1400 void dfs_print_nol(struct wlan_dfs *dfs); 1401 1402 /** 1403 * dfs_print_filter() - Prints the filter. 1404 * @dfs: Pointer to wlan_dfs structure. 1405 * @rf: Pointer to dfs_filter structure. 1406 */ 1407 void dfs_print_filter(struct wlan_dfs *dfs, 1408 struct dfs_filter *rf); 1409 1410 /** 1411 * dfs_getchanstate() - Get chan state. 1412 * @dfs: Pointer to wlan_dfs structure. 1413 * @index: To save the index of dfs_radar[] 1414 * @ext_chan_flag: Extension channel flag; 1415 */ 1416 struct dfs_state *dfs_getchanstate(struct wlan_dfs *dfs, 1417 uint8_t *index, 1418 int ext_ch_flag); 1419 1420 /** 1421 * dfs_round() - DFS found. 1422 * @val: Convert durations to TSF ticks. 1423 * 1424 * Return: TSF ticks. 1425 */ 1426 uint32_t dfs_round(int32_t val); 1427 1428 /** 1429 * dfs_reset_alldelaylines() - Reset alldelaylines. 1430 * @dfs: Pointer to wlan_dfs structure. 1431 */ 1432 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 1433 void dfs_reset_alldelaylines(struct wlan_dfs *dfs); 1434 #else 1435 static inline void dfs_reset_alldelaylines(struct wlan_dfs *dfs) 1436 { 1437 } 1438 #endif 1439 1440 /** 1441 * dfs_reset_delayline() - Clear only a single delay line. 1442 * @dl: Pointer to dfs_delayline structure. 1443 */ 1444 void dfs_reset_delayline(struct dfs_delayline *dl); 1445 1446 /** 1447 * dfs_reset_filter_delaylines() - Reset filter delaylines. 1448 * @dft: Pointer to dfs_filtertype structure. 1449 */ 1450 void dfs_reset_filter_delaylines(struct dfs_filtertype *dft); 1451 1452 /** 1453 * dfs_reset_radarq() - Reset radar queue. 1454 * @dfs: Pointer to wlan_dfs structure. 1455 */ 1456 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 1457 void dfs_reset_radarq(struct wlan_dfs *dfs); 1458 #else 1459 static inline void dfs_reset_radarq(struct wlan_dfs *dfs) 1460 { 1461 } 1462 #endif 1463 1464 /** 1465 * dfs_add_pulse() - Adds pulse to the queue. 1466 * @dfs: Pointer to wlan_dfs structure. 1467 * @rf: Pointer to dfs_filter structure. 1468 * @re: Pointer to dfs_event structure. 1469 * @deltaT: deltaT value. 1470 * @this_ts: Last time stamp. 1471 */ 1472 void dfs_add_pulse(struct wlan_dfs *dfs, 1473 struct dfs_filter *rf, 1474 struct dfs_event *re, 1475 uint32_t deltaT, 1476 uint64_t this_ts); 1477 1478 /** 1479 * dfs_bin_check() - BIN check 1480 * @dfs: Pointer to wlan_dfs structure. 1481 * @rf: Pointer to dfs_filter structure. 1482 * @deltaT: deltaT value. 1483 * @width: Width 1484 * @ext_chan_flag: Extension channel flag. 1485 */ 1486 int dfs_bin_check(struct wlan_dfs *dfs, 1487 struct dfs_filter *rf, 1488 uint32_t deltaT, 1489 uint32_t dur, 1490 int ext_chan_flag); 1491 1492 /** 1493 * dfs_bin_pri_check() - BIN PRI check 1494 * @dfs: Pointer to wlan_dfs structure. 1495 * @rf: Pointer to dfs_filter structure. 1496 * @dl: Pointer to dfs_delayline structure. 1497 * @score: Primary score. 1498 * @refpri: Current "filter" time for start of pulse in usecs. 1499 * @refdur: Duration value. 1500 * @ext_chan_flag: Extension channel flag. 1501 * @fundamentalpri: Highest PRI. 1502 */ 1503 int dfs_bin_pri_check(struct wlan_dfs *dfs, 1504 struct dfs_filter *rf, 1505 struct dfs_delayline *dl, 1506 uint32_t score, 1507 uint32_t refpri, 1508 uint32_t refdur, 1509 int ext_chan_flag, 1510 int fundamentalpri); 1511 1512 /** 1513 * dfs_staggered_check() - Detection implementation for staggered PRIs. 1514 * @dfs: Pointer to wlan_dfs structure. 1515 * @rf: Pointer to dfs_filter structure. 1516 * @deltaT: Delta of the Timestamp. 1517 * @width: Duration of radar pulse. 1518 * 1519 * Return: 1 on success and 0 on failure. 1520 */ 1521 int dfs_staggered_check(struct wlan_dfs *dfs, 1522 struct dfs_filter *rf, 1523 uint32_t deltaT, 1524 uint32_t width); 1525 1526 /** 1527 * dfs_get_pri_margin() - Get Primary margin. 1528 * @dfs: Pointer to wlan_dfs structure. 1529 * @is_extchan_detect: Extension channel detect. 1530 * @is_fixed_pattern: Fixed pattern. 1531 * 1532 * For the extension channel, if legacy traffic is present, we see a lot of 1533 * false alarms, so make the PRI margin narrower depending on the busy % for 1534 * the extension channel. 1535 * 1536 * Return: Returns pri_margin. 1537 */ 1538 int dfs_get_pri_margin(struct wlan_dfs *dfs, 1539 int is_extchan_detect, 1540 int is_fixed_pattern); 1541 1542 /** 1543 * dfs_get_filter_threshold() - Get filter threshold. 1544 * @dfs: Pointer to wlan_dfs structure. 1545 * @rf: Pointer to dfs_filter structure. 1546 * @is_extchan_detect: Extension channel detect. 1547 * 1548 * For the extension channel, if legacy traffic is present, we see a lot of 1549 * false alarms, so make the thresholds higher depending on the busy % for the 1550 * extension channel. 1551 * 1552 * Return: Returns threshold. 1553 */ 1554 int dfs_get_filter_threshold(struct wlan_dfs *dfs, 1555 struct dfs_filter *rf, 1556 int is_extchan_detect); 1557 1558 /** 1559 * dfs_process_ar_event() - Process the ar event. 1560 * @dfs: Pointer to wlan_dfs structure. 1561 * @chan: Current channel structure. 1562 */ 1563 void dfs_process_ar_event(struct wlan_dfs *dfs, 1564 struct dfs_channel *chan); 1565 1566 /** 1567 * dfs_reset_ar() - resets the ar state. 1568 * @dfs: pointer to wlan_dfs structure. 1569 */ 1570 void dfs_reset_ar(struct wlan_dfs *dfs); 1571 1572 /** 1573 * dfs_reset_arq() - resets the ar queue. 1574 * @dfs: pointer to wlan_dfs structure. 1575 */ 1576 void dfs_reset_arq(struct wlan_dfs *dfs); 1577 1578 /** 1579 * dfs_process_phyerr_bb_tlv() - Parses the PHY error and populates the 1580 * dfs_phy_err struct. 1581 * @dfs: Pointer to wlan_dfs structure. 1582 * @buf: Phyerr buffer 1583 * @datalen: Phyerr buf len 1584 * @rssi: RSSI 1585 * @ext_rssi: Extension RSSI. 1586 * @rs_tstamp: Time stamp. 1587 * @fulltsf: TSF64. 1588 * @e: Pointer to dfs_phy_err structure. 1589 * 1590 * Return: Returns 1. 1591 */ 1592 int dfs_process_phyerr_bb_tlv(struct wlan_dfs *dfs, 1593 void *buf, 1594 uint16_t datalen, 1595 uint8_t rssi, 1596 uint8_t ext_rssi, 1597 uint32_t rs_tstamp, 1598 uint64_t fulltsf, 1599 struct dfs_phy_err *e); 1600 1601 /** 1602 * dfs_reset() - DFS reset 1603 * @dfs: Pointer to wlan_dfs structure. 1604 */ 1605 void dfs_reset(struct wlan_dfs *dfs); 1606 1607 /** 1608 * dfs_radar_enable() - Enables the radar. 1609 * @dfs: Pointer to wlan_dfs structure. 1610 * @no_cac: If no_cac is 0, it cancels the CAC. 1611 */ 1612 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 1613 void dfs_radar_enable(struct wlan_dfs *dfs, 1614 int no_cac, uint32_t opmode); 1615 #else 1616 static inline void dfs_radar_enable(struct wlan_dfs *dfs, 1617 int no_cac, uint32_t opmode) 1618 { 1619 } 1620 #endif 1621 1622 /** 1623 * dfs_process_phyerr() - Process phyerr. 1624 * @dfs: Pointer to wlan_dfs structure. 1625 * @buf: Phyerr buffer. 1626 * @datalen: phyerr buffer length. 1627 * @r_rssi: RSSI. 1628 * @r_ext_rssi: Extension channel RSSI. 1629 * @r_rs_tstamp: Timestamp. 1630 * @r_fulltsf: TSF64. 1631 */ 1632 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 1633 void dfs_process_phyerr(struct wlan_dfs *dfs, 1634 void *buf, 1635 uint16_t datalen, 1636 uint8_t r_rssi, 1637 uint8_t r_ext_rssi, 1638 uint32_t r_rs_tstamp, 1639 uint64_t r_fulltsf); 1640 #else 1641 static inline void dfs_process_phyerr(struct wlan_dfs *dfs, 1642 void *buf, 1643 uint16_t datalen, 1644 uint8_t r_rssi, 1645 uint8_t r_ext_rssi, 1646 uint32_t r_rs_tstamp, 1647 uint64_t r_fulltsf) 1648 { 1649 } 1650 #endif 1651 1652 #ifdef QCA_MCL_DFS_SUPPORT 1653 /** 1654 * dfs_process_phyerr_filter_offload() - Process radar event. 1655 * @dfs: Pointer to wlan_dfs structure. 1656 * @wlan_radar_event: Pointer to radar_event_info structure. 1657 * 1658 * Return: None 1659 */ 1660 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) 1661 void dfs_process_phyerr_filter_offload(struct wlan_dfs *dfs, 1662 struct radar_event_info *wlan_radar_event); 1663 #else 1664 static inline void dfs_process_phyerr_filter_offload( 1665 struct wlan_dfs *dfs, 1666 struct radar_event_info *wlan_radar_event) 1667 { 1668 } 1669 #endif 1670 #endif 1671 1672 /** 1673 * dfs_get_radars() - Based on the chipset, calls init radar table functions. 1674 * @dfs: Pointer to wlan_dfs structure. 1675 */ 1676 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 1677 void dfs_get_radars(struct wlan_dfs *dfs); 1678 #else 1679 static inline void dfs_get_radars(struct wlan_dfs *dfs) 1680 { 1681 } 1682 #endif 1683 1684 /** 1685 * dfs_attach() - Wrapper function to allocate memory for wlan_dfs members. 1686 * @dfs: Pointer to wlan_dfs structure. 1687 */ 1688 int dfs_attach(struct wlan_dfs *dfs); 1689 1690 1691 /** 1692 * dfs_create_object() - Creates DFS object. 1693 * @dfs: Pointer to wlan_dfs structure. 1694 */ 1695 int dfs_create_object(struct wlan_dfs **dfs); 1696 1697 /** 1698 * dfs_destroy_object() - Destroys the DFS object. 1699 * @dfs: Pointer to wlan_dfs structure. 1700 */ 1701 void dfs_destroy_object(struct wlan_dfs *dfs); 1702 1703 /** 1704 * dfs_detach() - Wrapper function to free dfs variables. 1705 * @dfs: Pointer to wlan_dfs structure. 1706 */ 1707 void dfs_detach(struct wlan_dfs *dfs); 1708 1709 /** 1710 * dfs_cac_valid_reset() - Cancels the dfs_cac_valid_timer timer. 1711 * @dfs: Pointer to wlan_dfs structure. 1712 * @prevchan_ieee: Prevchan number. 1713 * @prevchan_flags: Prevchan flags. 1714 */ 1715 void dfs_cac_valid_reset(struct wlan_dfs *dfs, 1716 uint8_t prevchan_ieee, 1717 uint32_t prevchan_flags); 1718 1719 /** 1720 * dfs_cac_stop() - Clear the AP CAC timer. 1721 * @dfs: Pointer to wlan_dfs structure. 1722 */ 1723 void dfs_cac_stop(struct wlan_dfs *dfs); 1724 1725 /** 1726 * dfs_cancel_cac_timer() - Cancels the CAC timer. 1727 * @dfs: Pointer to wlan_dfs structure. 1728 */ 1729 void dfs_cancel_cac_timer(struct wlan_dfs *dfs); 1730 1731 /** 1732 * dfs_start_cac_timer() - Starts the CAC timer. 1733 * @dfs: Pointer to wlan_dfs structure. 1734 */ 1735 void dfs_start_cac_timer(struct wlan_dfs *dfs); 1736 1737 /** 1738 * dfs_set_update_nol_flag() - Sets update_nol flag. 1739 * @dfs: Pointer to wlan_dfs structure. 1740 * @val: update_nol flag. 1741 */ 1742 void dfs_set_update_nol_flag(struct wlan_dfs *dfs, 1743 bool val); 1744 1745 /** 1746 * dfs_get_update_nol_flag() - Returns update_nol flag. 1747 * @dfs: Pointer to wlan_dfs structure. 1748 */ 1749 bool dfs_get_update_nol_flag(struct wlan_dfs *dfs); 1750 1751 /** 1752 * dfs_get_use_nol() - Get usenol. 1753 * @dfs: Pointer to wlan_dfs structure. 1754 */ 1755 int dfs_get_use_nol(struct wlan_dfs *dfs); 1756 1757 /** 1758 * dfs_get_nol_timeout() - Get NOL timeout. 1759 * @dfs: Pointer to wlan_dfs structure. 1760 */ 1761 int dfs_get_nol_timeout(struct wlan_dfs *dfs); 1762 1763 /** 1764 * dfs_is_ap_cac_timer_running() - Returns the dfs cac timer. 1765 * @dfs: Pointer to wlan_dfs structure. 1766 */ 1767 int dfs_is_ap_cac_timer_running(struct wlan_dfs *dfs); 1768 1769 /** 1770 * dfs_control()- Used to process ioctls related to DFS. 1771 * @dfs: Pointer to wlan_dfs structure. 1772 * @id: Command type. 1773 * @indata: Input buffer. 1774 * @insize: size of the input buffer. 1775 * @outdata: A buffer for the results. 1776 * @outsize: Size of the output buffer. 1777 */ 1778 int dfs_control(struct wlan_dfs *dfs, 1779 u_int id, 1780 void *indata, 1781 uint32_t insize, 1782 void *outdata, 1783 uint32_t *outsize); 1784 1785 /** 1786 * dfs_getnol() - Wrapper function for dfs_get_nol() 1787 * @dfs: Pointer to wlan_dfs structure. 1788 * @dfs_nolinfo: Pointer to dfsreq_nolinfo structure. 1789 */ 1790 void dfs_getnol(struct wlan_dfs *dfs, 1791 void *dfs_nolinfo); 1792 1793 /** 1794 * dfs_get_override_cac_timeout() - Get override CAC timeout value. 1795 * @dfs: Pointer to DFS object. 1796 * @cac_timeout: Pointer to save the CAC timeout value. 1797 */ 1798 int dfs_get_override_cac_timeout(struct wlan_dfs *dfs, 1799 int *cac_timeout); 1800 1801 /** 1802 * dfs_override_cac_timeout() - Override the default CAC timeout. 1803 * @dfs: Pointer to DFS object. 1804 * @cac_timeout: CAC timeout value. 1805 */ 1806 int dfs_override_cac_timeout(struct wlan_dfs *dfs, 1807 int cac_timeout); 1808 1809 /** 1810 * dfs_clear_nolhistory() - unmarks WLAN_CHAN_CLR_HISTORY_RADAR flag for 1811 * all the channels in dfs_ch_channels. 1812 * @dfs: Pointer to wlan_dfs structure. 1813 */ 1814 void dfs_clear_nolhistory(struct wlan_dfs *dfs); 1815 1816 /** 1817 * ol_if_dfs_configure() - Initialize the RADAR table for offload chipsets. 1818 * @dfs: Pointer to wlan_dfs structure. 1819 * 1820 * This is called during a channel change or regulatory domain 1821 * reset; in order to fetch the new configuration information and 1822 * program the DFS pattern matching module. 1823 * 1824 * Eventually this should be split into "fetch config" (which can 1825 * happen at regdomain selection time) and "configure DFS" (which 1826 * can happen at channel config time) so as to minimise overheads 1827 * when doing channel changes. However, this'll do for now. 1828 */ 1829 void ol_if_dfs_configure(struct wlan_dfs *dfs); 1830 1831 /** 1832 * dfs_init_radar_filters() - Init Radar filters. 1833 * @dfs: Pointer to wlan_dfs structure. 1834 * @radar_info: Pointer to wlan_dfs_radar_tab_info structure. 1835 */ 1836 int dfs_init_radar_filters(struct wlan_dfs *dfs, 1837 struct wlan_dfs_radar_tab_info *radar_info); 1838 1839 /** 1840 * dfs_get_radars_for_ar5212() - Initialize radar table for AR5212 chipsets. 1841 * @dfs: Pointer to wlan_dfs structure. 1842 */ 1843 void dfs_get_radars_for_ar5212(struct wlan_dfs *dfs); 1844 1845 /** 1846 * dfs_get_radars_for_ar5416() - Initialize radar table for AR5416 chipsets. 1847 * @dfs: Pointer to wlan_dfs structure. 1848 */ 1849 void dfs_get_radars_for_ar5416(struct wlan_dfs *dfs); 1850 1851 /** 1852 * dfs_get_radars_for_ar9300() - Initialize radar table for AR9300 chipsets. 1853 * @dfs: Pointer to wlan_dfs structure. 1854 */ 1855 void dfs_get_radars_for_ar9300(struct wlan_dfs *dfs); 1856 1857 /** 1858 * dfs_print_filters() - Print the filters. 1859 * @dfs: Pointer to wlan_dfs structure. 1860 */ 1861 void dfs_print_filters(struct wlan_dfs *dfs); 1862 1863 /** 1864 * dfs_clear_stats() - Clear stats. 1865 * @dfs: Pointer to wlan_dfs structure. 1866 */ 1867 void dfs_clear_stats(struct wlan_dfs *dfs); 1868 1869 /** 1870 * dfs_radar_disable() - Disables the radar. 1871 * @dfs: Pointer to wlan_dfs structure. 1872 */ 1873 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 1874 int dfs_radar_disable(struct wlan_dfs *dfs); 1875 #else 1876 static inline int dfs_radar_disable(struct wlan_dfs *dfs) 1877 { 1878 return 0; 1879 } 1880 #endif 1881 1882 /** 1883 * dfs_get_debug_info() - Get debug info. 1884 * @dfs: Pointer to wlan_dfs structure. 1885 * @data: void pointer to the data to save dfs_proc_phyerr. 1886 */ 1887 int dfs_get_debug_info(struct wlan_dfs *dfs, 1888 void *data); 1889 1890 /** 1891 * dfs_cac_timer_init() - Initialize cac timers. 1892 * @dfs: Pointer to wlan_dfs structure. 1893 */ 1894 void dfs_cac_timer_init(struct wlan_dfs *dfs); 1895 1896 /** 1897 * dfs_cac_attach() - Initialize dfs cac variables. 1898 * @dfs: Pointer to wlan_dfs structure. 1899 */ 1900 void dfs_cac_attach(struct wlan_dfs *dfs); 1901 1902 /** 1903 * dfs_cac_timer_reset() - Cancel dfs cac timers. 1904 * @dfs: Pointer to wlan_dfs structure. 1905 */ 1906 void dfs_cac_timer_reset(struct wlan_dfs *dfs); 1907 1908 /** 1909 * dfs_nol_timer_init() - Initialize NOL timers. 1910 * @dfs: Pointer to wlan_dfs structure. 1911 */ 1912 void dfs_nol_timer_init(struct wlan_dfs *dfs); 1913 1914 /** 1915 * dfs_nol_attach() - Initialize NOL variables. 1916 * @dfs: Pointer to wlan_dfs structure. 1917 */ 1918 void dfs_nol_attach(struct wlan_dfs *dfs); 1919 1920 /** 1921 * dfs_nol_detach() - Detach NOL variables. 1922 * @dfs: Pointer to wlan_dfs structure. 1923 */ 1924 void dfs_nol_detach(struct wlan_dfs *dfs); 1925 1926 /** 1927 * dfs_print_nolhistory() - Print NOL history. 1928 * @dfs: Pointer to wlan_dfs structure. 1929 */ 1930 void dfs_print_nolhistory(struct wlan_dfs *dfs); 1931 1932 /** 1933 * dfs_stacac_stop() - Clear the STA CAC timer. 1934 * @dfs: Pointer to wlan_dfs structure. 1935 */ 1936 void dfs_stacac_stop(struct wlan_dfs *dfs); 1937 1938 /** 1939 * dfs_find_precac_secondary_vht80_chan() - Get a VHT80 channel with the 1940 * precac primary center frequency. 1941 * @dfs: Pointer to wlan_dfs structure. 1942 * @chan: Pointer to dfs channel structure. 1943 */ 1944 void dfs_find_precac_secondary_vht80_chan(struct wlan_dfs *dfs, 1945 struct dfs_channel *chan); 1946 1947 /** 1948 * dfs_phyerr_param_copy() - Function to copy src buf to dest buf. 1949 * @dst: dest buf. 1950 * @src: src buf. 1951 */ 1952 void dfs_phyerr_param_copy(struct wlan_dfs_phyerr_param *dst, 1953 struct wlan_dfs_phyerr_param *src); 1954 1955 /** 1956 * dfs_get_thresholds() - Get the threshold value. 1957 * @dfs: Pointer to wlan_dfs structure. 1958 * @param: Pointer to wlan_dfs_phyerr_param structure. 1959 */ 1960 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 1961 int dfs_get_thresholds(struct wlan_dfs *dfs, 1962 struct wlan_dfs_phyerr_param *param); 1963 #else 1964 static inline int dfs_get_thresholds(struct wlan_dfs *dfs, 1965 struct wlan_dfs_phyerr_param *param) 1966 { 1967 return 0; 1968 } 1969 #endif 1970 1971 /** 1972 * dfs_set_thresholds() - Sets the threshold value. 1973 * @dfs: Pointer to wlan_dfs structure. 1974 * @threshtype: DFS ioctl param type. 1975 * @value: Threshold value. 1976 */ 1977 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 1978 int dfs_set_thresholds(struct wlan_dfs *dfs, 1979 const uint32_t threshtype, 1980 const uint32_t value); 1981 #else 1982 static inline int dfs_set_thresholds(struct wlan_dfs *dfs, 1983 const uint32_t threshtype, 1984 const uint32_t value) 1985 { 1986 return 0; 1987 } 1988 #endif 1989 1990 /** 1991 * dfs_set_current_channel() - Set DFS current channel. 1992 * @dfs: Pointer to wlan_dfs structure. 1993 * @dfs_ch_freq: Frequency in Mhz. 1994 * @dfs_ch_flags: Channel flags. 1995 * @dfs_ch_flagext: Extended channel flags. 1996 * @dfs_ch_ieee: IEEE channel number. 1997 * @dfs_ch_vhtop_ch_freq_seg1: Channel Center frequency1. 1998 * @dfs_ch_vhtop_ch_freq_seg2: Channel Center frequency2. 1999 */ 2000 void dfs_set_current_channel(struct wlan_dfs *dfs, 2001 uint16_t dfs_ch_freq, 2002 uint64_t dfs_ch_flags, 2003 uint16_t dfs_ch_flagext, 2004 uint8_t dfs_ch_ieee, 2005 uint8_t dfs_ch_vhtop_ch_freq_seg1, 2006 uint8_t dfs_ch_vhtop_ch_freq_seg2); 2007 2008 /** 2009 * dfs_get_nol_chfreq_and_chwidth() - Get channel freq and width from NOL list. 2010 * @dfs_nol: Pointer to NOL channel entry. 2011 * @nol_chfreq: Pointer to save channel frequency. 2012 * @nol_chwidth: Pointer to save channel width. 2013 * @index: Index to dfs_nol list. 2014 */ 2015 void dfs_get_nol_chfreq_and_chwidth(struct dfsreq_nolelem *dfs_nol, 2016 uint32_t *nol_chfreq, 2017 uint32_t *nol_chwidth, 2018 int index); 2019 2020 /** 2021 * dfs_process_phyerr_owl() - Process an Owl-style phy error. 2022 * @dfs: Pointer to wlan_dfs structure. 2023 * @buf: Phyerr buffer 2024 * @datalen: Phyerr buf len 2025 * @rssi: RSSI 2026 * @ext_rssi: Extension RSSI. 2027 * @rs_tstamp: Time stamp. 2028 * @fulltsf: TSF64. 2029 * @e: Pointer to dfs_phy_err structure. 2030 * 2031 * Return: Returns 1. 2032 */ 2033 int dfs_process_phyerr_owl(struct wlan_dfs *dfs, 2034 void *buf, 2035 uint16_t datalen, 2036 uint8_t rssi, 2037 uint8_t ext_rssi, 2038 uint32_t rs_tstamp, 2039 uint64_t fulltsf, 2040 struct dfs_phy_err *e); 2041 2042 /** 2043 * dfs_process_phyerr_sowl() -Process a Sowl/Howl style phy error. 2044 * @dfs: Pointer to wlan_dfs structure. 2045 * @buf: Phyerr buffer 2046 * @datalen: Phyerr buf len 2047 * @rssi: RSSI 2048 * @ext_rssi: Extension RSSI. 2049 * @rs_tstamp: Time stamp. 2050 * @fulltsf: TSF64. 2051 * @e: Pointer to dfs_phy_err structure. 2052 * 2053 * Return: Returns 1. 2054 */ 2055 int dfs_process_phyerr_sowl(struct wlan_dfs *dfs, 2056 void *buf, 2057 uint16_t datalen, 2058 uint8_t rssi, 2059 uint8_t ext_rssi, 2060 uint32_t rs_tstamp, 2061 uint64_t fulltsf, 2062 struct dfs_phy_err *e); 2063 2064 /** 2065 * dfs_process_phyerr_merlin() - Process a Merlin/Osprey style phy error. 2066 * dfs_phy_err struct. 2067 * @dfs: Pointer to wlan_dfs structure. 2068 * @buf: Phyerr buffer 2069 * @datalen: Phyerr buf len 2070 * @rssi: RSSI 2071 * @ext_rssi: Extension RSSI. 2072 * @rs_tstamp: Time stamp. 2073 * @fulltsf: TSF64. 2074 * @e: Pointer to dfs_phy_err structure. 2075 * 2076 * Return: Returns 1. 2077 */ 2078 int dfs_process_phyerr_merlin(struct wlan_dfs *dfs, 2079 void *buf, 2080 uint16_t datalen, 2081 uint8_t rssi, 2082 uint8_t ext_rssi, 2083 uint32_t rs_tstamp, 2084 uint64_t fulltsf, 2085 struct dfs_phy_err *e); 2086 2087 /* 2088 * __dfs_process_radarevent() - Continuation of process a radar event function. 2089 * @dfs: Pointer to wlan_dfs structure. 2090 * @ft: Pointer to dfs_filtertype structure. 2091 * @re: Pointer to dfs_event structure. 2092 * @this_ts: Timestamp. 2093 * 2094 * There is currently no way to specify that a radar event has occurred on 2095 * a specific channel, so the current methodology is to mark both the pri 2096 * and ext channels as being unavailable. This should be fixed for 802.11ac 2097 * or we'll quickly run out of valid channels to use. 2098 * 2099 * Return: If a radar event is found, return 1. Otherwise, return 0. 2100 */ 2101 void __dfs_process_radarevent(struct wlan_dfs *dfs, 2102 struct dfs_filtertype *ft, 2103 struct dfs_event *re, 2104 uint64_t this_ts, 2105 int *found, 2106 int *false_radar_found); 2107 2108 /** 2109 * bin5_rules_check_internal() - This is a extension of dfs_bin5_check(). 2110 * @dfs: Pointer to wlan_dfs structure. 2111 * @br: Pointer to dfs_bin5radars structure. 2112 * @bursts: Bursts. 2113 * @numevents: Number of events. 2114 * @prev: prev index. 2115 * @i: Index. 2116 * @this: index to br_elems[] 2117 */ 2118 void bin5_rules_check_internal(struct wlan_dfs *dfs, 2119 struct dfs_bin5radars *br, 2120 uint32_t *bursts, 2121 uint32_t *numevents, 2122 uint32_t prev, 2123 uint32_t i, 2124 uint32_t this, 2125 int *index); 2126 2127 /** 2128 * dfs_main_task_testtimer_init() - Initialize dfs task testtimer. 2129 * @dfs: Pointer to wlan_dfs structure. 2130 */ 2131 void dfs_main_task_testtimer_init(struct wlan_dfs *dfs); 2132 2133 /** 2134 * dfs_stop() - Clear dfs timers. 2135 * @dfs: Pointer to wlan_dfs structure. 2136 */ 2137 void dfs_stop(struct wlan_dfs *dfs); 2138 2139 /** 2140 * dfs_update_cur_chan_flags() - Update DFS channel flag and flagext. 2141 * @dfs: Pointer to wlan_dfs structure. 2142 * @flags: New channel flags 2143 * @flagext: New Extended flags 2144 */ 2145 void dfs_update_cur_chan_flags(struct wlan_dfs *dfs, 2146 uint64_t flags, 2147 uint16_t flagext); 2148 2149 /** 2150 * dfs_radarevent_basic_sanity() - Check basic sanity of the radar event 2151 * @dfs: Pointer to wlan_dfs structure. 2152 * @chan: Current channel. 2153 * 2154 * Return: If a radar event found on NON-DFS channel return 0. Otherwise, 2155 * return 1. 2156 */ 2157 int dfs_radarevent_basic_sanity(struct wlan_dfs *dfs, 2158 struct dfs_channel *chan); 2159 2160 /** 2161 * wlan_psoc_get_dfs_txops() - Get dfs_tx_ops pointer 2162 * @psoc: Pointer to psoc structure. 2163 * 2164 * Return: Pointer to dfs_tx_ops. 2165 */ 2166 struct wlan_lmac_if_dfs_tx_ops * 2167 wlan_psoc_get_dfs_txops(struct wlan_objmgr_psoc *psoc); 2168 2169 /** 2170 * dfs_nol_free_list() - Free NOL elements. 2171 * @dfs: Pointer to wlan_dfs structure. 2172 */ 2173 void dfs_nol_free_list(struct wlan_dfs *dfs); 2174 2175 /** 2176 * dfs_second_segment_radar_disable() - Disables the second segment radar. 2177 * @dfs: Pointer to wlan_dfs structure. 2178 * 2179 * This is called when AP detects the radar, to (potentially) disable 2180 * the radar code. 2181 * 2182 * Return: returns 0. 2183 */ 2184 int dfs_second_segment_radar_disable(struct wlan_dfs *dfs); 2185 2186 #endif /* _DFS_H_ */ 2187