1 /* 2 * Copyright (c) 2013, 2016-2020 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 #include <qdf_str.h> /* qdf_str_lcopy */ 33 34 #include <wlan_dfs_ioctl.h> 35 #include "dfs_structs.h" 36 #include "dfs_channel.h" 37 #include "dfs_ioctl_private.h" 38 #include <i_qdf_types.h> /* For qdf_packed*/ 39 #include "queue.h" /* For STAILQ_ENTRY */ 40 #include <wlan_objmgr_psoc_obj.h> 41 #include <wlan_objmgr_pdev_obj.h> 42 #include <osdep.h> 43 #include <wlan_cmn.h> 44 #include "target_type.h" 45 #ifdef QCA_SUPPORT_ADFS_RCAC 46 #include <wlan_sm_engine.h> /* for struct wlan_sm */ 47 #endif 48 #include <wlan_dfs_public_struct.h> 49 #include <reg_services_public_struct.h> 50 51 /* File Line and Submodule String */ 52 #define FLSM(x, str) #str " : " FL(x) 53 /* Cast to dfs type */ 54 #define DC(x) ((struct wlan_dfs *)(x)) 55 56 /** 57 * dfs_log: dfs logging using submodule MASKs and 58 * QDF trace level. 59 * The logging is controlled by two bitmasks: 60 * 1) submodule bitmask: sm 61 * 2) trace level masks: level 62 * 63 * @dfs: The dfs object pointer or NULL if dfs is not defined. 64 * @sm: Submodule BITMASK. 65 * @level: QDF trace level. 66 * @args...: Variable argument list. 67 * 68 * The submodule(sm) cannot be empty even if argument dfs is NULL. 69 * Else the macro will create a compilation error. 70 * One may provide WLAN_DEBUG_DFS_ALWAYS when the argument dfs is NULL. 71 * Example:- 72 * dfs_log(NULL, WLAN_DEBUG_DFS_ALWAYS, QDF_TRACE_LEVEL_INFO,"Error pulse"); 73 * 74 * Why DC(x) is required? 75 * Since NULL is defined as ((void *)(0)), if the argument "dfs" 76 * in a call to the macro "dfs_log" is NULL 77 * then during compilation (NULL)->dfs_debug_mask will dereference 78 * a (void *) type, which is illegal. Therefore, we need 79 * the cast: (DC(dfs))->dfs_debug_mask. 80 * Example:- 81 * dfs_log(NULL, WLAN_DEBUG_DFS, QDF_TRACE_LEVEL_INFO,"dfs is NULL"); 82 */ 83 #define dfs_log(dfs, sm, level, args...) do { \ 84 if (((dfs) == NULL) || \ 85 ((sm) == WLAN_DEBUG_DFS_ALWAYS) || \ 86 ((sm) & ((DC(dfs))->dfs_debug_mask))) { \ 87 QDF_TRACE(QDF_MODULE_ID_DFS, level, ## args); \ 88 } \ 89 } while (0) 90 91 #define dfs_logfl(dfs, level, sm, format, args...) \ 92 dfs_log(dfs, sm, level, FLSM(format, sm), ## args) 93 94 #define dfs_alert(dfs, sm, format, args...) \ 95 dfs_logfl(dfs, QDF_TRACE_LEVEL_FATAL, sm, format, ## args) 96 97 #define dfs_err(dfs, sm, format, args...) \ 98 dfs_logfl(dfs, QDF_TRACE_LEVEL_ERROR, sm, format, ## args) 99 100 #define dfs_warn(dfs, sm, format, args...) \ 101 dfs_logfl(dfs, QDF_TRACE_LEVEL_WARN, sm, format, ## args) 102 103 #define dfs_info(dfs, sm, format, args...) \ 104 dfs_logfl(dfs, QDF_TRACE_LEVEL_INFO, sm, format, ## args) 105 106 #define dfs_debug(dfs, sm, format, args...) \ 107 dfs_logfl(dfs, QDF_TRACE_LEVEL_DEBUG, sm, format, ## args) 108 109 #define DFS_MIN(a, b) ((a) < (b)?(a):(b)) 110 #define DFS_MAX(a, b) ((a) > (b)?(a) : (b)) 111 #define DFS_DIFF(a, b)(DFS_MAX(a, b) - DFS_MIN(a, b)) 112 113 /** 114 * Maximum number of radar events to be processed in a single iteration. 115 * Allows soft watchdog to run. 116 */ 117 #define MAX_EVENTS 100 118 119 /** 120 * Constants to use for chirping detection. 121 * 122 * All are unconverted as HW reports them. 123 * 124 * XXX Are these constants with or without fast clock 5GHz operation? 125 * XXX Peregrine reports pulses in microseconds, not hardware clocks! 126 */ 127 128 #define MAX_DUR_FOR_LOW_RSSI 4 129 130 /** 131 * Cascade has issue with reported duration especially when there is a 132 * crossover of chirp from one segment to another. It may report a value 133 * of duration that is well below 50us for a valid FCC type 5 chirping 134 * pulse. For now changing minimum duration as a work around. This will 135 * affect all chips but since we detect chirp with Merlin+, we may be OK 136 * for now. We need a more robust solution for this. 137 */ 138 #define MIN_BIN5_DUR_CAS 25 /* 50 * 1.25*/ 139 #define MIN_BIN5_DUR_MICROSEC_CAS 20 140 #define MIN_BIN5_DUR 63 /* 50 * 1.25*/ 141 #define MIN_BIN5_DUR_MICROSEC 50 142 #define MAYBE_BIN5_DUR 35 /* 28 * 1.25*/ 143 #define MAYBE_BIN5_DUR_MICROSEC 28 144 145 /* Conversion is already done using dfs->dur_multiplier */ 146 #define MAX_BIN5_DUR 145 /* use 145 for osprey */ 147 #define MAX_BIN5_DUR_MICROSEC 105 148 149 #define DFS_MARGIN_EQUAL(a, b, margin) ((DFS_DIFF(a, b)) <= margin) 150 #define DFS_MAX_STAGGERED_BURSTS 3 151 152 /** 153 * All filter thresholds in the radar filter tables are effective at a 50% 154 * channel loading. 155 */ 156 #define DFS_CHAN_LOADING_THRESH 50 157 #define DFS_EXT_CHAN_LOADING_THRESH 30 158 #define DFS_DEFAULT_PRI_MARGIN 6 159 #define DFS_DEFAULT_FIXEDPATTERN_PRI_MARGIN 4 160 161 #define WLAN_DFSQ_LOCK(_dfs) qdf_spin_lock_bh(&(_dfs)->dfs_radarqlock) 162 #define WLAN_DFSQ_UNLOCK(_dfs) qdf_spin_unlock_bh(&(_dfs)->dfs_radarqlock) 163 #define WLAN_DFSQ_LOCK_CREATE(_dfs) qdf_spinlock_create( \ 164 &(_dfs)->dfs_radarqlock) 165 #define WLAN_DFSQ_LOCK_DESTROY(_dfs) qdf_spinlock_destroy( \ 166 &(_dfs)->dfs_radarqlock) 167 168 #define WLAN_ARQ_LOCK(_dfs) qdf_spin_lock_bh(&(_dfs)->dfs_arqlock) 169 #define WLAN_ARQ_UNLOCK(_dfs) qdf_spin_unlock_bh(&(_dfs)->dfs_arqlock) 170 #define WLAN_ARQ_LOCK_CREATE(_dfs) qdf_spinlock_create(&(_dfs)->dfs_arqlock) 171 #define WLAN_ARQ_LOCK_DESTROY(_dfs) qdf_spinlock_destroy(&(_dfs)->dfs_arqlock) 172 173 #define WLAN_DFSEVENTQ_LOCK(_dfs) qdf_spin_lock_bh(&(_dfs)->dfs_eventqlock) 174 #define WLAN_DFSEVENTQ_UNLOCK(_dfs) qdf_spin_unlock_bh( \ 175 &(_dfs)->dfs_eventqlock) 176 #define WLAN_DFSEVENTQ_LOCK_CREATE(_dfs) qdf_spinlock_create( \ 177 &(_dfs)->dfs_eventqlock) 178 #define WLAN_DFSEVENTQ_LOCK_DESTROY(_dfs) qdf_spinlock_destroy( \ 179 &(_dfs)->dfs_eventqlock) 180 181 #define WLAN_DFSNOL_LOCK(_dfs) qdf_spin_lock_bh(&(_dfs)->dfs_nol_lock) 182 #define WLAN_DFSNOL_UNLOCK(_dfs) qdf_spin_unlock_bh(&(_dfs)->dfs_nol_lock) 183 #define WLAN_DFSNOL_LOCK_CREATE(_dfs) qdf_spinlock_create( \ 184 &(_dfs)->dfs_nol_lock) 185 #define WLAN_DFSNOL_LOCK_DESTROY(_dfs) qdf_spinlock_destroy( \ 186 &(_dfs)->dfs_nol_lock) 187 188 #define PRECAC_LIST_LOCK(_dfs) qdf_spin_lock_irqsave( \ 189 &(_dfs)->dfs_precac_lock) 190 #define PRECAC_LIST_UNLOCK(_dfs) qdf_spin_unlock_irqrestore( \ 191 &(_dfs)->dfs_precac_lock) 192 #define PRECAC_LIST_LOCK_CREATE(_dfs) qdf_spinlock_create( \ 193 &(_dfs)->dfs_precac_lock) 194 #define PRECAC_LIST_LOCK_DESTROY(_dfs) qdf_spinlock_destroy( \ 195 &(_dfs)->dfs_precac_lock) 196 197 #define WLAN_DFS_DATA_STRUCT_LOCK(_dfs) \ 198 qdf_spin_lock_bh(&(_dfs)->dfs_data_struct_lock) 199 #define WLAN_DFS_DATA_STRUCT_UNLOCK(_dfs) \ 200 qdf_spin_unlock_bh(&(_dfs)->dfs_data_struct_lock) 201 #define WLAN_DFS_DATA_STRUCT_LOCK_CREATE(_dfs) \ 202 qdf_spinlock_create(&(_dfs)->dfs_data_struct_lock) 203 #define WLAN_DFS_DATA_STRUCT_LOCK_DESTROY(_dfs) \ 204 qdf_spinlock_destroy(&(_dfs)->dfs_data_struct_lock) 205 206 /* Wrappers to call MLME radar during mode switch lock. */ 207 #define DFS_RADAR_MODE_SWITCH_LOCK(_dfs) \ 208 dfs_mlme_acquire_radar_mode_switch_lock((_dfs)->dfs_pdev_obj) 209 #define DFS_RADAR_MODE_SWITCH_UNLOCK(_dfs) \ 210 dfs_mlme_release_radar_mode_switch_lock((_dfs)->dfs_pdev_obj) 211 212 /* Mask for time stamp from descriptor */ 213 #define DFS_TSMASK 0xFFFFFFFF 214 /* Shift for time stamp from descriptor */ 215 #define DFS_TSSHIFT 32 216 /* 64 bit TSF wrap value */ 217 #define DFS_TSF_WRAP 0xFFFFFFFFFFFFFFFFULL 218 /* TS mask for 64 bit value */ 219 #define DFS_64BIT_TSFMASK 0x0000000000007FFFULL 220 221 #define DFS_AR_RADAR_RSSI_THR 5 /* in dB */ 222 #define DFS_AR_RADAR_RESET_INT 1 /* in secs */ 223 #define DFS_AR_RADAR_MAX_HISTORY 500 224 #define DFS_AR_REGION_WIDTH 128 225 #define DFS_AR_RSSI_THRESH_STRONG_PKTS 17 /* in dB */ 226 #define DFS_AR_RSSI_DOUBLE_THRESHOLD 15 /* in dB */ 227 #define DFS_AR_MAX_NUM_ACK_REGIONS 9 228 #define DFS_AR_ACK_DETECT_PAR_THRESH 20 229 #define DFS_AR_PKT_COUNT_THRESH 20 230 231 #define DFS_MAX_DL_SIZE 64 232 #define DFS_MAX_DL_MASK 0x3F 233 234 #define DFS_NOL_TIME DFS_NOL_TIMEOUT_US 235 /* 30 minutes in usecs */ 236 237 #define DFS_WAIT_TIME (60*1000000) /* 1 minute in usecs */ 238 239 #define DFS_DISABLE_TIME (3*60*1000000) /* 3 minutes in usecs */ 240 241 #define DFS_MAX_B5_SIZE 128 242 #define DFS_MAX_B5_MASK 0x0000007F /* 128 */ 243 244 /* Max number of overlapping filters */ 245 #define DFS_MAX_RADAR_OVERLAP 16 246 247 /* Max number of dfs events which can be q'd */ 248 #define DFS_MAX_EVENTS 1024 249 250 #define DFS_RADAR_EN 0x80000000 /* Radar detect is capable */ 251 #define DFS_AR_EN 0x40000000 /* AR detect is capable */ 252 /* Radar detect in second segment is capable */ 253 #define DFS_SECOND_SEGMENT_RADAR_EN 0x20000000 254 #define DFS_MAX_RSSI_VALUE 0x7fffffff /* Max rssi value */ 255 256 #define DFS_BIN_MAX_PULSES 60 /* max num of pulses in a burst */ 257 #define DFS_BIN5_PRI_LOWER_LIMIT 990 /* us */ 258 259 /** 260 * To cover the single pusle burst case, change from 2010 us to 261 * 2010000 us. 262 */ 263 264 /** 265 * This is reverted back to 2010 as larger value causes false 266 * bin5 detect (EV76432, EV76320) 267 */ 268 #define DFS_BIN5_PRI_HIGHER_LIMIT 2010 /* us */ 269 270 #define DFS_BIN5_WIDTH_MARGIN 4 /* us */ 271 #define DFS_BIN5_RSSI_MARGIN 5 /* dBm */ 272 273 /** 274 * Following threshold is not specified but should be 275 * okay statistically. 276 */ 277 #define DFS_BIN5_BRI_LOWER_LIMIT 300000 /* us */ 278 #define DFS_BIN5_BRI_UPPER_LIMIT 12000000 /* us */ 279 280 /* Max number of pulses kept in buffer */ 281 #define DFS_MAX_PULSE_BUFFER_SIZE 1024 282 #define DFS_MAX_PULSE_BUFFER_MASK 0x3ff 283 284 #define DFS_FAST_CLOCK_MULTIPLIER (800/11) 285 #define DFS_NO_FAST_CLOCK_MULTIPLIER (80) 286 #define DFS_BIG_SIDX 10000 287 288 /* Min value of valid psidx diff */ 289 #define DFS_MIN_PSIDX_DIFF 4 290 /* Max value of valid psidx diff */ 291 #define DFS_MAX_PSIDX_DIFF 16 292 293 /** 294 * Software use: channel interference used for as AR as well as RADAR 295 * interference detection. 296 */ 297 #define CHANNEL_INTERFERENCE 0x01 298 299 #define CHANNEL_2GHZ 0x00080 /* 2 GHz spectrum channel. */ 300 #define CHANNEL_OFDM 0x00040 /* OFDM channel */ 301 #define CHANNEL_TURBO 0x00010 /* Turbo Channel */ 302 #define CHANNEL_108G (CHANNEL_2GHZ|CHANNEL_OFDM|CHANNEL_TURBO) 303 304 /* qdf_packed - denotes structure is packed. */ 305 #define qdf_packed __qdf_packed 306 307 #define SEG_ID_PRIMARY 0 308 #define SEG_ID_SECONDARY 1 309 310 /* MIN and MAX width for different regions */ 311 #define REG0_MIN_WIDTH 33 312 #define REG0_MAX_WIDTH 38 313 #define REG1_MIN_WIDTH 39 314 #define REG1_MAX_WIDTH 44 315 #define REG2_MIN_WIDTH 53 316 #define REG2_MAX_WIDTH 58 317 #define REG3_MIN_WIDTH 126 318 #define REG3_MAX_WIDTH 140 319 #define REG4_MIN_WIDTH 141 320 #define REG4_MAX_WIDTH 160 321 #define REG5_MIN_WIDTH 189 322 #define REG5_MAX_WIDTH 210 323 #define REG6_MIN_WIDTH 360 324 #define REG6_MAX_WIDTH 380 325 #define REG7_MIN_WIDTH 257 326 #define REG7_MAX_WIDTH 270 327 #define REG8_MIN_WIDTH 295 328 #define REG8_MAX_WIDTH 302 329 330 #define OVER_SAMPLING_FREQ 44000 331 #define SAMPLING_FREQ 40000 332 #define HUNDRED 100 333 #define NUM_BINS 128 334 #define THOUSAND 1000 335 336 /* Array offset to ETSI legacy pulse */ 337 #define ETSI_LEGACY_PULSE_ARR_OFFSET 4 338 339 #define ETSI_RADAR_EN302_502_FREQ_LOWER 5725 340 #define ETSI_RADAR_EN302_502_FREQ_UPPER 5865 341 342 #define DFS_NOL_ADD_CHAN_LOCKED(dfs, freq, timeout) \ 343 do { \ 344 WLAN_DFSNOL_LOCK(dfs); \ 345 dfs_nol_addchan(dfs, freq, timeout); \ 346 WLAN_DFSNOL_UNLOCK(dfs); \ 347 } while (0) 348 349 /* 350 * Free the NOL element in a thread. This is to avoid freeing the 351 * timer object from within timer callback function . The nol element 352 * contains the timer Object. 353 */ 354 #define DFS_NOL_DELETE_CHAN_LOCKED(dfs, freq, chwidth) \ 355 do { \ 356 WLAN_DFSNOL_LOCK(dfs); \ 357 dfs_nol_delete(dfs, freq, chwidth); \ 358 qdf_sched_work(NULL, &dfs->dfs_nol_elem_free_work); \ 359 WLAN_DFSNOL_UNLOCK(dfs); \ 360 } while (0) 361 362 #define DFS_GET_NOL_LOCKED(dfs, dfs_nol, nchan) \ 363 do { \ 364 WLAN_DFSNOL_LOCK(dfs); \ 365 dfs_get_nol(dfs, dfs_nol, nchan); \ 366 WLAN_DFSNOL_UNLOCK(dfs); \ 367 } while (0) 368 369 #define DFS_PRINT_NOL_LOCKED(dfs) \ 370 do { \ 371 WLAN_DFSNOL_LOCK(dfs); \ 372 dfs_print_nol(dfs); \ 373 WLAN_DFSNOL_UNLOCK(dfs); \ 374 } while (0) 375 376 #define DFS_NOL_FREE_LIST_LOCKED(dfs) \ 377 do { \ 378 WLAN_DFSNOL_LOCK(dfs); \ 379 dfs_nol_free_list(dfs); \ 380 WLAN_DFSNOL_UNLOCK(dfs); \ 381 } while (0) 382 383 /* Host sends the average parameters of the radar pulses and starts the status 384 * wait timer with this timeout. 385 */ 386 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 387 #define HOST_DFS_STATUS_WAIT_TIMER_MS 200 388 #endif 389 390 /* 391 * USENOL_DISABLE_NOL_HOST_AND_FW : Do not add radar hit channel to NOL 392 * in host and FW. Enable CSA on the same channel. 393 */ 394 #define USENOL_DISABLE_NOL_HOST_AND_FW 0 395 /* 396 * USENOL_ENABLE_NOL_HOST_AND_FW : Add the radar hit channel to NOL in 397 * host and FW (in case of FO). NOL timer cannot be configured by the user 398 * as FW does not allow manipulating NOL timeout. If noltimeout is configured, 399 * (say 1 min) FW will not be intimated about the configuration and hence NOL 400 * timer may elapse at different instances in host (after 1 min) and FW (after 401 * default 30 min) which could lead to DFS Violation if host tries to come up 402 * on the channel after host NOL timeout (of 1 min) as the FW would still 403 * have the channel in NOL list. 404 */ 405 #define USENOL_ENABLE_NOL_HOST_AND_FW 1 406 /* 407 * USENOL_ENABLE_NOL_HOST_DISABLE_NOL_FW : Add the radar hit channel to NOL 408 * in host. NOL timer can be configured by user. NOL in FW (for FO) is disabled. 409 */ 410 #define USENOL_ENABLE_NOL_HOST_DISABLE_NOL_FW 2 411 412 /** 413 * enum detector_id - Detector ID values. 414 * @DETECTOR_ID_0: Detector ID 0 (Non Agile). 415 * @DETECTOR_ID_1: Detector ID 1 (Non Agile in 80p80MHz supported devices, 416 * Agile detector in true 160MHz supported devices). 417 * @DETECTOR_ID_2: Detector ID 2 (Agile detector in 80p80MHZ supported devices). 418 * @AGILE_DETECTOR_ID_TRUE_160MHZ: Agile detector ID in true 160MHz devices. 419 * @AGILE_DETECTOR_ID_80p80: Agile detector ID in 80p80MHz supported devices. 420 * @INVALID_DETECTOR_ID: Invalid detector id. 421 */ 422 enum detector_id { 423 DETECTOR_ID_0, 424 DETECTOR_ID_1, 425 DETECTOR_ID_2, 426 AGILE_DETECTOR_ID_TRUE_160MHZ = DETECTOR_ID_1, 427 AGILE_DETECTOR_ID_80P80 = DETECTOR_ID_2, 428 INVALID_DETECTOR_ID, 429 }; 430 431 /** 432 * struct dfs_pulseparams - DFS pulse param structure. 433 * @p_time: Time for start of pulse in usecs. 434 * @p_dur: Duration of pulse in usecs. 435 * @p_rssi: RSSI of pulse. 436 * @p_seg_id: Segment id. 437 * @p_sidx: Sidx value. 438 * @p_delta_peak: Delta peak value. 439 * @p_psidx_diff: The difference in the FFT peak index between the short FFT 440 * and the first long FFT. 441 * @p_seq_num: Sequence number. 442 */ 443 struct dfs_pulseparams { 444 uint64_t p_time; 445 uint8_t p_dur; 446 uint8_t p_rssi; 447 uint8_t p_seg_id; 448 int16_t p_sidx; 449 int8_t p_delta_peak; 450 int16_t p_psidx_diff; 451 uint32_t p_seq_num; 452 } qdf_packed; 453 454 /** 455 * struct dfs_pulseline - Pulseline structure. 456 * @pl_elems[]: array of pulses in delay line. 457 * @pl_firstelem: Index of the first element. 458 * @pl_lastelem: Index of the last element. 459 * @pl_numelems: Number of elements in the delay line. 460 */ 461 struct dfs_pulseline { 462 struct dfs_pulseparams pl_elems[DFS_MAX_PULSE_BUFFER_SIZE]; 463 uint32_t pl_firstelem; 464 uint32_t pl_lastelem; 465 uint32_t pl_numelems; 466 } qdf_packed; 467 468 #define DFS_EVENT_CHECKCHIRP 0x01 /* Whether to check the chirp flag */ 469 #define DFS_EVENT_HW_CHIRP 0x02 /* hardware chirp */ 470 #define DFS_EVENT_SW_CHIRP 0x04 /* software chirp */ 471 /* Whether the event contains valid psidx diff value*/ 472 #define DFS_EVENT_VALID_PSIDX_DIFF 0x08 473 474 /* Use this only if the event has CHECKCHIRP set. */ 475 #define DFS_EVENT_ISCHIRP(e) \ 476 ((e)->re_flags & (DFS_EVENT_HW_CHIRP | DFS_EVENT_SW_CHIRP)) 477 478 /** 479 * Check if the given event is to be rejected as not possibly 480 * a chirp. This means: 481 * (a) it's a hardware or software checked chirp, and 482 * (b) the HW/SW chirp bits are both 0. 483 */ 484 #define DFS_EVENT_NOTCHIRP(e) \ 485 (((e)->re_flags & (DFS_EVENT_CHECKCHIRP)) && (!DFS_EVENT_ISCHIRP((e)))) 486 487 /** 488 * struct dfs_event - DFS event structure. 489 * @re_full_ts: 64-bit full timestamp from interrupt time. 490 * @re_ts: Original 15 bit recv timestamp. 491 * @re_rssi: Rssi of radar event. 492 * @re_dur: Duration of radar pulse. 493 * @re_chanindex: Channel of event. 494 * @re_flags: Event flags. 495 * @re_freq: Centre frequency of event, KHz. 496 * @re_freq_lo: Lower bounds of frequency, KHz. 497 * @re_freq_hi: Upper bounds of frequency, KHz. 498 * @re_seg_id: HT80_80/HT160 use. 499 * @re_sidx: Seg index. 500 * @re_freq_offset_khz: Freq offset in KHz 501 * @re_peak_mag: Peak mag. 502 * @re_total_gain: Total gain. 503 * @re_mb_gain: Mb gain. 504 * @re_relpwr_db: Relpower in db. 505 * @re_delta_diff: Delta diff. 506 * @re_delta_peak: Delta peak. 507 * @re_psidx_diff: Psidx diff. 508 * @re_list: List of radar events. 509 */ 510 struct dfs_event { 511 uint64_t re_full_ts; 512 uint32_t re_ts; 513 uint8_t re_rssi; 514 uint8_t re_dur; 515 uint8_t re_chanindex; 516 uint8_t re_flags; 517 uint32_t re_freq; 518 uint32_t re_freq_lo; 519 uint32_t re_freq_hi; 520 uint8_t re_seg_id; 521 int re_sidx; 522 u_int re_freq_offset_khz; 523 int re_peak_mag; 524 int re_total_gain; 525 int re_mb_gain; 526 int re_relpwr_db; 527 uint8_t re_delta_diff; 528 int8_t re_delta_peak; 529 int16_t re_psidx_diff; 530 531 STAILQ_ENTRY(dfs_event) re_list; 532 } qdf_packed; 533 534 #define DFS_AR_MAX_ACK_RADAR_DUR 511 535 #define DFS_AR_MAX_NUM_PEAKS 3 536 #define DFS_AR_ARQ_SIZE 2048 /* 8K AR events for buffer size */ 537 #define DFS_AR_ARQ_SEQSIZE 2049 /* Sequence counter wrap for AR */ 538 539 #define DFS_RADARQ_SIZE 512 /* 1K radar events for buffer size */ 540 #define DFS_RADARQ_SEQSIZE 513 /* Sequence counter wrap for radar */ 541 /* Number of radar channels we keep state for */ 542 #define DFS_NUM_RADAR_STATES 64 543 /* Max number radar filters for each type */ 544 #define DFS_MAX_NUM_RADAR_FILTERS 10 545 /* Number of different radar types */ 546 #define DFS_MAX_RADAR_TYPES 32 547 /* Number of filter index table rows */ 548 #define DFS_NUM_FT_IDX_TBL_ROWS 256 549 550 /* RADAR filter pattern type 1*/ 551 #define WLAN_DFS_RF_PATTERN_TYPE_1 1 552 553 /** 554 * struct dfs_ar_state - DFS AR state structure. 555 * @ar_prevwidth: Previous width. 556 * @ar_phyerrcount[]: Phy error count. 557 * @ar_acksum: Acksum. 558 * @ar_packetthreshold: Thresh to determine traffic load. 559 * @ar_parthreshold: Thresh to determine peak. 560 * @ar_radarrssi: Rssi threshold for AR event. 561 * @ar_prevtimestamp: Prev time stamp. 562 * @ar_peaklist[]: Peak list. 563 */ 564 struct dfs_ar_state { 565 uint32_t ar_prevwidth; 566 uint32_t ar_phyerrcount[DFS_AR_MAX_ACK_RADAR_DUR]; 567 uint32_t ar_acksum; 568 uint32_t ar_packetthreshold; 569 uint32_t ar_parthreshold; 570 uint32_t ar_radarrssi; 571 uint16_t ar_prevtimestamp; 572 uint16_t ar_peaklist[DFS_AR_MAX_NUM_PEAKS]; 573 }; 574 575 /** 576 * struct dfs_delayelem - Delay Element. 577 * @de_time: Current "filter" time for start of pulse in usecs. 578 * @de_dur: Duration of pulse in usecs. 579 * @de_rssi: Rssi of pulse in dB. 580 * @de_ts: Time stamp for this delay element. 581 * @de_seg_id: Segment id for HT80_80/HT160 use. 582 * @de_sidx: Sidx value. 583 * @de_delta_peak: Delta peak. 584 * @de_psidx_diff: Psidx diff. 585 * @de_seq_num: Sequence number. 586 */ 587 struct dfs_delayelem { 588 uint32_t de_time; 589 uint8_t de_dur; 590 uint8_t de_rssi; 591 uint64_t de_ts; 592 uint8_t de_seg_id; 593 int16_t de_sidx; 594 int8_t de_delta_peak; 595 int16_t de_psidx_diff; 596 uint32_t de_seq_num; 597 } qdf_packed; 598 599 /** 600 * struct dfs_delayline - DFS Delay Line. 601 * @dl_elems[]: Array of pulses in delay line. 602 * @dl_last_ts: Last timestamp the delay line was used (in usecs). 603 * @dl_firstelem: Index of the first element. 604 * @dl_lastelem: Index of the last element. 605 * @dl_numelems: Number of elements in the delay line. 606 * The following is to handle fractional PRI pulses that can cause false 607 * detection. 608 * @dl_seq_num_start: Sequence number of first pulse that was part of 609 * threshold match. 610 * @dl_seq_num_stop: Sequence number of last pulse that was part of threshold 611 * match. 612 * The following is required because the first pulse may or may not be in the 613 * delay line but we will find it iin the pulse line using dl_seq_num_second's 614 * diff_ts value. 615 * @dl_seq_num_second: Sequence number of second pulse that was part of 616 * threshold match. 617 * @dl_search_pri: We need final search PRI to identify possible fractional 618 * PRI issue. 619 * @dl_min_sidx: Minimum sidx value of pulses used to match thershold. 620 * Used for sidx spread check. 621 * @dl_max_sidx: Maximum sidx value of pulses used to match thershold. 622 * Used for sidx spread check. 623 * @dl_delta_peak_match_count: Number of pulse in the delay line that had valid 624 * delta peak value. 625 * @dl_psidx_diff_match_count: Number of pulse in the delay line that had valid 626 * psidx diff value. 627 */ 628 struct dfs_delayline { 629 struct dfs_delayelem dl_elems[DFS_MAX_DL_SIZE]; 630 uint64_t dl_last_ts; 631 uint32_t dl_firstelem; 632 uint32_t dl_lastelem; 633 uint32_t dl_numelems; 634 uint32_t dl_seq_num_start; 635 uint32_t dl_seq_num_stop; 636 uint32_t dl_seq_num_second; 637 uint32_t dl_search_pri; 638 int16_t dl_min_sidx; 639 int8_t dl_max_sidx; 640 uint8_t dl_delta_peak_match_count; 641 uint8_t dl_psidx_diff_match_count; 642 } qdf_packed; 643 644 /** 645 * struct dfs_filter - Dfs filter. 646 * @rf_dl: Delay line of pulses for this filter. 647 * @rf_numpulses: Number of pulses in the filter. 648 * @rf_minpri: Min pri to be considered for this filter. 649 * @rf_maxpri: Max pri to be considered for this filter. 650 * @rf_threshold: Match filter output threshold for radar detect. 651 * @rf_filterlen: Length (in usecs) of the filter. 652 * @rf_patterntype: Fixed or variable pattern type. 653 * @rf_fixed_pri_radar_pulse: indicates if it is a fixed pri pulse. 654 * @rf_mindur: Min duration for this radar filter. 655 * @rf_maxdur: Max duration for this radar filter. 656 * @rf_ignore_pri_window: Ignore pri window. 657 * @rf_pulseid: Unique ID corresponding to the original filter ID. 658 * To reduce false detection, look at frequency spread. For now we will use 659 * sidx spread. But for HT160 frequency spread will be a better measure. 660 * @rf_sidx_spread: Maximum SIDX value spread in a matched sequence 661 * excluding FCC Bin 5. 662 * @rf_check_delta_peak: Minimum allowed delta_peak value for a pulse to be 663 * considetred for this filter's match. 664 */ 665 struct dfs_filter { 666 struct dfs_delayline rf_dl; 667 uint32_t rf_numpulses; 668 uint32_t rf_minpri; 669 uint32_t rf_maxpri; 670 uint32_t rf_threshold; 671 uint32_t rf_filterlen; 672 uint32_t rf_patterntype; 673 uint32_t rf_fixed_pri_radar_pulse; 674 uint32_t rf_mindur; 675 uint32_t rf_maxdur; 676 uint32_t rf_ignore_pri_window; 677 uint32_t rf_pulseid; 678 uint16_t rf_sidx_spread; 679 int8_t rf_check_delta_peak; 680 } qdf_packed; 681 682 /** 683 * struct dfs_filtertype - Structure of DFS Filter type. 684 * @ft_filters[]: Array of ptrs storing addresses for struct of dfs_filter. 685 * @ft_filterdur: Duration of pulse which specifies filter type. 686 * @ft_numfilters: Num filters of this type. 687 * @ft_last_ts: Last timestamp this filtertype was used (in usecs). 688 * @ft_mindur: Min pulse duration to be considered for this filter type. 689 * @ft_maxdur: Max pulse duration to be considered for this filter type. 690 * @ft_rssithresh: Min rssi to be considered for this filter type. 691 * @ft_numpulses: Num pulses in each filter of this type. 692 * @ft_patterntype: Fixed or variable pattern type. 693 * @ft_minpri: Min pri to be considered for this type. 694 * @ft_rssimargin: Rssi threshold margin. In Turbo Mode HW reports rssi 3dB 695 * lower than in non TURBO mode. This will offset that diff. 696 */ 697 struct dfs_filtertype { 698 struct dfs_filter *ft_filters[DFS_MAX_NUM_RADAR_FILTERS]; 699 uint32_t ft_filterdur; 700 uint32_t ft_numfilters; 701 uint64_t ft_last_ts; 702 uint32_t ft_mindur; 703 uint32_t ft_maxdur; 704 uint32_t ft_rssithresh; 705 uint32_t ft_numpulses; 706 uint32_t ft_patterntype; 707 uint32_t ft_minpri; 708 uint32_t ft_rssimargin; 709 }; 710 711 /** 712 * struct dfs_channel - Channel structure for dfs component. 713 * @dfs_ch_freq: Frequency in Mhz. 714 * @dfs_ch_flags: Channel flags. 715 * @dfs_ch_flagext: Extended channel flags. 716 * @dfs_ch_ieee: IEEE channel number. 717 * @dfs_ch_vhtop_ch_freq_seg1: IEEE Channel Center of primary segment 718 * @dfs_ch_vhtop_ch_freq_seg2: IEEE Channel Center applicable for 80+80MHz 719 * mode of operation. 720 * @dfs_ch_mhz_freq_seg1: Channel center frequency of primary segment in 721 * MHZ. 722 * @dfs_ch_mhz_freq_seg2: Channel center frequency of secondary segment 723 * in MHZ applicable only for 80+80MHZ mode of 724 * operation. 725 */ 726 struct dfs_channel { 727 uint16_t dfs_ch_freq; 728 uint64_t dfs_ch_flags; 729 uint16_t dfs_ch_flagext; 730 uint8_t dfs_ch_ieee; 731 uint8_t dfs_ch_vhtop_ch_freq_seg1; 732 uint8_t dfs_ch_vhtop_ch_freq_seg2; 733 uint16_t dfs_ch_mhz_freq_seg1; 734 uint16_t dfs_ch_mhz_freq_seg2; 735 }; 736 737 /** 738 * struct dfs_state - DFS state. 739 * @rs_chan: Channel info. 740 * @rs_chanindex: Channel index in radar structure. 741 * @rs_numradarevents: Number of radar events. 742 * @rs_param: Phy param. 743 */ 744 struct dfs_state { 745 struct dfs_channel rs_chan; 746 uint8_t rs_chanindex; 747 uint32_t rs_numradarevents; 748 struct wlan_dfs_phyerr_param rs_param; 749 }; 750 751 #define DFS_NOL_TIMEOUT_S (30*60) /* 30 minutes in seconds */ 752 #define DFS_NOL_TIMEOUT_MS (DFS_NOL_TIMEOUT_S * 1000) 753 #define DFS_NOL_TIMEOUT_US (DFS_NOL_TIMEOUT_MS * 1000) 754 755 /** 756 * struct dfs_nolelem - DFS NOL element. 757 * @nol_dfs Back pointer to dfs object. 758 * @nol_freq: Centre frequency. 759 * @nol_chwidth: Event width (MHz). 760 * @nol_start_us: NOL start time in us. 761 * @nol_timeout_ms: NOL timeout value in msec. 762 * @nol_timer: Per element NOL timer. 763 * @nol_next: Next element pointer. 764 */ 765 struct dfs_nolelem { 766 TAILQ_ENTRY(dfs_nolelem) nolelem_list; 767 struct wlan_dfs *nol_dfs; 768 uint32_t nol_freq; 769 uint32_t nol_chwidth; 770 uint64_t nol_start_us; 771 uint32_t nol_timeout_ms; 772 qdf_timer_t nol_timer; 773 struct dfs_nolelem *nol_next; 774 } qdf_packed; 775 776 777 /** 778 * struct dfs_info - DFS Info. 779 * @rn_ftindex: Number of different types of radars. 780 * @rn_lastfull_ts: Last 64 bit timstamp from recv interrupt. 781 * @rn_last_ts: last 15 bit ts from recv descriptor. 782 * @rn_last_unique_ts: last unique 32 bit ts from recv descriptor. 783 * @rn_ts_prefix: Prefix to prepend to 15 bit recv ts. 784 * @rn_numbin5radars: Number of bin5 radar pulses to search for. 785 * @rn_fastdivGCval: Value of fast diversity gc limit from init file. 786 * @rn_minrssithresh: Min rssi for all radar types. 787 * @rn_maxpulsedur: Max pulse width in TSF ticks. 788 * @dfs_ext_chan_busy: Ext chan busy. 789 * @ext_chan_busy_ts: Ext chan busy time. 790 * @dfs_bin5_chirp_ts: Ext bin5 chrip time. 791 * @dfs_last_bin5_dur: Last bin5 during. 792 */ 793 struct dfs_info { 794 uint32_t rn_ftindex; 795 uint64_t rn_lastfull_ts; 796 uint16_t rn_last_ts; 797 uint32_t rn_last_unique_ts; 798 uint64_t rn_ts_prefix; 799 uint32_t rn_numbin5radars; 800 uint32_t rn_fastdivGCval; 801 int32_t rn_minrssithresh; 802 uint32_t rn_maxpulsedur; 803 uint8_t dfs_ext_chan_busy; 804 uint64_t ext_chan_busy_ts; 805 uint64_t dfs_bin5_chirp_ts; 806 uint8_t dfs_last_bin5_dur; 807 } qdf_packed; 808 809 /** 810 * struct dfs_bin5elem - BIN5 elements. 811 * @be_ts: Timestamp for the bin5 element. 812 * @be_rssi: Rssi for the bin5 element. 813 * @be_dur: Duration of bin5 element. 814 */ 815 struct dfs_bin5elem { 816 uint64_t be_ts; 817 uint32_t be_rssi; 818 uint32_t be_dur; 819 }; 820 821 /** 822 * struct dfs_bin5radars - BIN5 radars. 823 * @br_elems[]: List of bin5 elems that fall within the time window. 824 * @br_firstelem: Index of the first element. 825 * @br_lastelem: Index of the last element. 826 * @br_numelems: Number of elements in the delay line. 827 * @br_pulse: Original info about bin5 pulse. 828 */ 829 struct dfs_bin5radars { 830 struct dfs_bin5elem br_elems[DFS_MAX_B5_SIZE]; 831 uint32_t br_firstelem; 832 uint32_t br_lastelem; 833 uint32_t br_numelems; 834 struct dfs_bin5pulse br_pulse; 835 }; 836 837 /** 838 * struct dfs_stats - DFS stats. 839 * @num_radar_detects: Total num. of radar detects. 840 * @num_seg_two_radar_detects: Total num. of radar detected in secondary segment 841 * @total_phy_errors: Total PHY errors. 842 * @owl_phy_errors: OWL PHY errors. 843 * @pri_phy_errors: Primary channel phy errors. 844 * @ext_phy_errors: Extension channel phy errors. 845 * @dc_phy_errors: DC PHY errors. 846 * @early_ext_phy_errors: Extension channel early radar found error. 847 * @bwinfo_errors: Bogus bandwidth info received in descriptor. 848 * @datalen_discards: data length at least three bytes of payload. 849 * @rssi_discards: RSSI is not accurate. 850 * @last_reset_tstamp: Last reset timestamp. 851 */ 852 struct dfs_stats { 853 uint32_t num_radar_detects; 854 uint32_t num_seg_two_radar_detects; 855 uint32_t total_phy_errors; 856 uint32_t owl_phy_errors; 857 uint32_t pri_phy_errors; 858 uint32_t ext_phy_errors; 859 uint32_t dc_phy_errors; 860 uint32_t early_ext_phy_errors; 861 uint32_t bwinfo_errors; 862 uint32_t datalen_discards; 863 uint32_t rssi_discards; 864 uint64_t last_reset_tstamp; 865 }; 866 867 #define DFS_EVENT_LOG_SIZE 256 868 869 /** 870 * struct dfs_event_log - DFS event log. 871 * @ts: 64-bit full timestamp from interrupt time. 872 * @diff_ts: Diff timestamp. 873 * @rssi: Rssi of radar event. 874 * @dur: Duration of radar pulse. 875 * @is_chirp: Chirp flag. 876 * @seg_id: HT80_80/HT160 use. 877 * @sidx: Seg index. 878 * @freq_offset_khz: Freq offset in KHz 879 * @peak_mag: Peak mag. 880 * @total_gain: Total gain. 881 * @mb_gain: Mb gain. 882 * @relpwr_db: Relpower in db. 883 * @delta_diff: Delta diff. 884 * @delta_peak: Delta peak. 885 * @psidx_diff: Psidx diff. 886 */ 887 888 struct dfs_event_log { 889 uint64_t ts; 890 uint32_t diff_ts; 891 uint8_t rssi; 892 uint8_t dur; 893 int is_chirp; 894 uint8_t seg_id; 895 int sidx; 896 u_int freq_offset_khz; 897 int peak_mag; 898 int total_gain; 899 int mb_gain; 900 int relpwr_db; 901 uint8_t delta_diff; 902 int8_t delta_peak; 903 int16_t psidx_diff; 904 }; 905 906 #define WLAN_DFS_WEATHER_CHANNEL_WAIT_MIN 10 /*10 minutes*/ 907 #define WLAN_DFS_WEATHER_CHANNEL_WAIT_S (WLAN_DFS_WEATHER_CHANNEL_WAIT_MIN * 60) 908 #define WLAN_DFS_WEATHER_CHANNEL_WAIT_MS \ 909 ((WLAN_DFS_WEATHER_CHANNEL_WAIT_S) * 1000) /*in MS*/ 910 911 #define WLAN_DFS_WAIT_POLL_PERIOD 2 /* 2 seconds */ 912 #define WLAN_DFS_WAIT_POLL_PERIOD_MS \ 913 ((WLAN_DFS_WAIT_POLL_PERIOD) * 1000) /*in MS*/ 914 915 #define DFS_DEBUG_TIMEOUT_S 30 /* debug timeout is 30 seconds */ 916 #define DFS_DEBUG_TIMEOUT_MS (DFS_DEBUG_TIMEOUT_S * 1000) 917 918 #define RSSI_POSSIBLY_FALSE 50 919 #define SEARCH_FFT_REPORT_PEAK_MAG_THRSH 40 920 921 #define MIN_DFS_SUBCHAN_BW 20 /* Minimum bandwidth of each subchannel. */ 922 923 #define FREQ_OFFSET_BOUNDARY_FOR_80MHZ 40 924 925 #define FREQ_OFFSET_BOUNDARY_FOR_160MHZ 80 926 927 /** 928 * struct dfs_mode_switch_defer_params - Parameters storing DFS information 929 * before defer, as part of HW mode switch. 930 * 931 * @radar_params: Deferred radar parameters. 932 * @is_cac_completed: Boolean representing CAC completion event. 933 * @is_radar_detected: Boolean representing radar event. 934 */ 935 struct dfs_mode_switch_defer_params { 936 struct radar_found_info *radar_params; 937 bool is_cac_completed; 938 bool is_radar_detected; 939 }; 940 941 #ifdef QCA_SUPPORT_ADFS_RCAC 942 #define DFS_PSOC_NO_IDX 0xFF 943 /** 944 * enum dfs_rcac_sm_state - DFS Rolling CAC SM states. 945 * @DFS_RCAC_S_INIT: Default state, where RCAC not in progress. 946 * @DFS_RCAC_S_RUNNING: RCAC is in progress. 947 * @DFS_RCAC_S_COMPLETE: RCAC is completed. 948 * @DFS_RCAC_S_MAX: Max (invalid) state. 949 */ 950 enum dfs_rcac_sm_state { 951 DFS_RCAC_S_INIT, 952 DFS_RCAC_S_RUNNING, 953 DFS_RCAC_S_COMPLETE, 954 DFS_RCAC_S_MAX, 955 }; 956 957 /** 958 * struct dfs_rcac_params - DFS Rolling CAC channel parameters. 959 * @rcac_pri_freq: Rolling CAC channel's primary frequency. 960 * @rcac_ch_params: Rolling CAC channel parameters. 961 */ 962 struct dfs_rcac_params { 963 qdf_freq_t rcac_pri_freq; 964 struct ch_params rcac_ch_params; 965 }; 966 #endif 967 968 /** 969 * struct wlan_dfs - The main dfs structure. 970 * @dfs_debug_mask: Current debug bitmask. 971 * @dfs_curchan_radindex: Current channel radar index. 972 * @dfs_extchan_radindex: Extension channel radar index. 973 * @dfsdomain: Current DFS domain. 974 * @dfs_proc_phyerr: Flags for Phy Errs to process. 975 * @dfs_eventq: Q of free dfs event objects. 976 * @dfs_eventqlock: Lock for free dfs event list. 977 * @dfs_radarq: Q of radar events. 978 * @dfs_radarqlock: Lock for dfs q. 979 * @dfs_arq: Q of AR events. 980 * @dfs_arqlock: Lock for AR q. 981 * @dfs_ar_state: AR state. 982 * @dfs_radar[]: Per-Channel Radar detector state. 983 * @dfs_radarf[]: One filter for each radar pulse type. 984 * @dfs_rinfo: State vars for radar processing. 985 * @dfs_b5radars: Array of bin5 radar events. 986 * @dfs_ftindextable: Map of radar durs to filter types. 987 * @dfs_nol: Non occupancy list for radar. 988 * @dfs_nol_count: How many items? 989 * @dfs_defaultparams: Default phy params per radar state. 990 * @wlan_dfs_stats: DFS related stats. 991 * @pulses: Pulse history. 992 * @events: Events structure. 993 * @wlan_radar_tasksched: Radar task is scheduled. 994 * @wlan_dfswait: Waiting on channel for radar detect. 995 * @wlan_dfstest: Test timer in progress. 996 * @dfs_caps: Object of wlan_dfs_caps structure. 997 * @wlan_dfstest_ieeechan: IEEE chan num to return to after a dfs mute 998 * test. 999 * @wlan_dfs_cac_time: CAC period. 1000 * @wlan_dfstesttime: Time to stay off chan during dfs test. 1001 * @wlan_dfswaittimer: Dfs wait timer. 1002 * @wlan_dfstesttimer: Dfs mute test timer. 1003 * @wlan_dfs_debug_timer: Dfs debug timer. 1004 * @dfs_bangradar_type: Radar simulation type. 1005 * @is_radar_found_on_secondary_seg: Radar on second segment. 1006 * @dfs_radar_found_for_fo: Radar found event for FO(Full Offload) is 1007 * received. 1008 * @is_radar_during_precac: Radar found during precac. 1009 * @dfs_precac_lock: Lock to protect precac lists. 1010 * @dfs_precac_secondary_freq: Second segment freq for precac. 1011 * Applicable to only legacy chips. 1012 * @dfs_precac_secondary_freq_mhz: Second segment freq in MHZ for precac. 1013 * Applicable to only legacy chips. 1014 * @dfs_precac_primary_freq: PreCAC Primary freq applicable only to 1015 * legacy chips. 1016 * @dfs_precac_primary_freq_mhz: PreCAC Primary freq in MHZ applicable only 1017 * to legacy chips. 1018 * @dfs_defer_precac_channel_change: Defer precac channel change. 1019 * @dfs_precac_inter_chan: Intermediate non-DFS channel used while 1020 * doing precac. 1021 * @dfs_precac_inter_chan_freq: Intermediate non-DFS freq used while 1022 * doing precac. 1023 * @dfs_autoswitch_des_chan: Desired channel which has to be used 1024 * after precac. 1025 * @dfs_autoswitch_des_chan_freq: Desired freq which has to be used 1026 * after precac. 1027 * @dfs_autoswitch_des_mode: Desired PHY mode which has to be used 1028 * after precac. 1029 * @dfs_pre_cac_timeout_channel_change: Channel change due to precac timeout. 1030 * @wlan_dfs_task_timer: Dfs wait timer. 1031 * @dur_multiplier: Duration multiplier. 1032 * @wlan_dfs_isdfsregdomain: True when AP is in DFS domain 1033 * @wlan_dfs_false_rssi_thres: False RSSI Threshold. 1034 * @wlan_dfs_peak_mag: Peak mag. 1035 * @radar_log[]: Radar log. 1036 * @dfs_event_log_count: Event log count. 1037 * @dfs_event_log_on: Event log on. 1038 * @dfs_phyerr_count: Same as number of PHY radar interrupts. 1039 * @dfs_phyerr_reject_count: When TLV is supported, # of radar events 1040 * ignored after TLV is parsed. 1041 * @dfs_phyerr_queued_count: Number of radar events queued for matching 1042 * the filters. 1043 * @dfs_phyerr_freq_min: Phyerr min freq. 1044 * @dfs_phyerr_freq_max: Phyerr max freq. 1045 * @dfs_phyerr_w53_counter: Phyerr w53 counter. 1046 * @dfs_pri_multiplier: Allow pulse if they are within multiple of 1047 * PRI for the radar type. 1048 * @wlan_dfs_nol_timeout: NOL timeout. 1049 * @update_nol: Update NOL. 1050 * @dfs_seq_num: Sequence number. 1051 * @dfs_nol_event[]: NOL event. 1052 * @dfs_nol_timer: NOL list processing. 1053 * @dfs_nol_free_list: NOL free list. 1054 * @dfs_nol_elem_free_work: The work queue to free an NOL element. 1055 * @dfs_cac_timer: CAC timer. 1056 * @dfs_cac_valid_timer: Ignore CAC when this timer is running. 1057 * @dfs_cac_timeout_override: Overridden cac timeout. 1058 * @dfs_enable: DFS Enable. 1059 * @dfs_cac_timer_running: DFS CAC timer running. 1060 * @dfs_ignore_dfs: Ignore DFS. 1061 * @dfs_ignore_cac: Ignore CAC. 1062 * @dfs_cac_valid: DFS CAC valid. 1063 * @dfs_cac_valid_time: Time for which CAC will be valid and will 1064 * not be re-done. 1065 * @dfs_precac_timeout_override: Overridden precac timeout. 1066 * @dfs_num_precac_freqs: Number of PreCAC VHT80 frequencies. 1067 * @dfs_precac_list: PreCAC list (contains individual trees). 1068 * @dfs_precac_chwidth: PreCAC channel width enum. 1069 * @dfs_curchan: DFS current channel. 1070 * @dfs_prevchan: DFS previous channel. 1071 * @dfs_cac_started_chan: CAC started channel. 1072 * @dfs_pdev_obj: DFS pdev object. 1073 * @dfs_is_offload_enabled: Set if DFS offload enabled. 1074 * @dfs_agile_precac_freq_mhz: Freq in MHZ configured on Agile DFS engine. 1075 * @dfs_use_nol: Use the NOL when radar found(default: TRUE) 1076 * @dfs_nol_lock: Lock to protect nol list. 1077 * @tx_leakage_threshold: Tx leakage threshold for dfs. 1078 * @dfs_use_nol_subchannel_marking: Use subchannel marking logic to add only 1079 * radar affected subchannel instead of all 1080 * bonding channels. 1081 * @dfs_host_wait_timer: The timer that is started from host after 1082 * sending the average radar parameters. 1083 * Before this timeout host expects its dfs 1084 * status from fw. 1085 * @dfs_average_pri: Average pri value of the received radar 1086 * pulses. 1087 * @dfs_average_duration: Average duration of the received radar 1088 * pulses. 1089 * @dfs_average_sidx: Average sidx of the received radar pulses. 1090 * @dfs_is_host_wait_running: Indicates if host dfs status wait timer is 1091 * running. 1092 * @dfs_average_params_sent: Indicates if host has sent the average 1093 * radar parameters. 1094 * @dfs_no_res_from_fw: Indicates no response from fw. 1095 * @dfs_spoof_check_failed: Indicates if the spoof check has failed. 1096 * @dfs_spoof_test_done: Indicates if the sppof test is done. 1097 * @dfs_status_timeout_override: Used to change the timeout value of 1098 * dfs_host_wait_timer. 1099 * @dfs_is_stadfs_enabled: Is STADFS enabled. 1100 * @dfs_min_sidx: Minimum sidx of the received radar pulses. 1101 * @dfs_max_sidx: Maximum sidx of the received radar pulses. 1102 * @dfs_seg_id: Segment ID of the radar hit channel. 1103 * @dfs_is_chirp: Radar Chirp in pulse present or not. 1104 * @dfs_bw_reduced: DFS bandwidth reduced channel bit. 1105 * @dfs_freq_offset: Frequency offset where radar was found. 1106 * @dfs_cac_aborted: DFS cac is aborted. 1107 * @dfs_disable_radar_marking: To mark or unmark NOL chan as radar hit. 1108 * @dfs_data_struct_lock: DFS data structure lock. This is to protect 1109 * all the filtering data structures. For 1110 * example: dfs_bin5radars, dfs_filtertype, 1111 * etc. 1112 * @dfs_nol_ie_bandwidth: Minimum Bandwidth of subchannels that 1113 * are added to NOL. 1114 * @dfs_nol_ie_startfreq: The centre frequency of the starting 1115 * subchannel in the current channel list 1116 * to be sent in NOL IE with RCSA. 1117 * @dfs_nol_ie_bitmap: The bitmap of radar affected subchannels 1118 * in the current channel list 1119 * to be sent in NOL IE with RCSA. 1120 * @dfs_is_rcsa_ie_sent: To send or to not send RCSA IE. 1121 * @dfs_is_nol_ie_sent: To send or to not send NOL IE. 1122 * @dfs_legacy_precac_ucfg: User configuration for legacy preCAC in 1123 * partial offload chipsets. 1124 * @dfs_agile_precac_ucfg: User configuration for agile preCAC. 1125 * @dfs_agile_rcac_ucfg: User configuration for Rolling CAC. 1126 * @dfs_fw_adfs_support_non_160: Target Agile DFS support for non-160 BWs. 1127 * @dfs_fw_adfs_support_160: Target Agile DFS support for 160 BW. 1128 * @dfs_allow_hw_pulses: Allow/Block HW pulses. When synthetic 1129 * pulses are injected, the HW pulses should 1130 * be blocked and this variable should be 1131 * false so that HW pulses and synthetic 1132 * pulses do not get mixed up. 1133 * defer timer running. 1134 * @dfs_defer_params: DFS deferred event parameters (allocated 1135 * only for the duration of defer alone). 1136 * @dfs_agile_detector_id: Agile detector ID for the DFS object. 1137 * @dfs_agile_rcac_freq_ucfg: User programmed Rolling CAC frequency in 1138 * MHZ. 1139 * @dfs_rcac_param: Primary frequency and Channel params of 1140 * the selected RCAC channel. 1141 */ 1142 struct wlan_dfs { 1143 uint32_t dfs_debug_mask; 1144 int16_t dfs_curchan_radindex; 1145 int16_t dfs_extchan_radindex; 1146 uint32_t dfsdomain; 1147 uint32_t dfs_proc_phyerr; 1148 1149 STAILQ_HEAD(, dfs_event) dfs_eventq; 1150 qdf_spinlock_t dfs_eventqlock; 1151 1152 STAILQ_HEAD(, dfs_event) dfs_radarq; 1153 qdf_spinlock_t dfs_radarqlock; 1154 1155 STAILQ_HEAD(, dfs_event) dfs_arq; 1156 qdf_spinlock_t dfs_arqlock; 1157 1158 struct dfs_ar_state dfs_ar_state; 1159 struct dfs_state dfs_radar[DFS_NUM_RADAR_STATES]; 1160 struct dfs_filtertype *dfs_radarf[DFS_MAX_RADAR_TYPES]; 1161 struct dfs_info dfs_rinfo; 1162 struct dfs_bin5radars *dfs_b5radars; 1163 int8_t **dfs_ftindextable; 1164 struct dfs_nolelem *dfs_nol; 1165 int dfs_nol_count; 1166 struct wlan_dfs_phyerr_param dfs_defaultparams; 1167 struct dfs_stats wlan_dfs_stats; 1168 struct dfs_pulseline *pulses; 1169 struct dfs_event *events; 1170 1171 uint32_t wlan_radar_tasksched:1, 1172 wlan_dfswait:1, 1173 wlan_dfstest:1; 1174 struct wlan_dfs_caps dfs_caps; 1175 uint8_t wlan_dfstest_ieeechan; 1176 uint32_t wlan_dfs_cac_time; 1177 uint32_t wlan_dfstesttime; 1178 qdf_timer_t wlan_dfswaittimer; 1179 qdf_timer_t wlan_dfstesttimer; 1180 qdf_timer_t wlan_dfs_debug_timer; 1181 enum dfs_bangradar_types dfs_bangradar_type; 1182 bool is_radar_found_on_secondary_seg; 1183 bool dfs_radar_found_for_fo; 1184 bool is_radar_during_precac; 1185 qdf_spinlock_t dfs_precac_lock; 1186 bool dfs_precac_enable; 1187 #ifdef CONFIG_CHAN_NUM_API 1188 uint8_t dfs_precac_secondary_freq; 1189 uint8_t dfs_precac_primary_freq; 1190 #endif 1191 #ifdef CONFIG_CHAN_FREQ_API 1192 uint16_t dfs_precac_secondary_freq_mhz; 1193 uint16_t dfs_precac_primary_freq_mhz; 1194 #endif 1195 uint8_t dfs_defer_precac_channel_change; 1196 #ifdef WLAN_DFS_PRECAC_AUTO_CHAN_SUPPORT 1197 #ifdef CONFIG_CHAN_NUM_API 1198 uint8_t dfs_precac_inter_chan; 1199 uint8_t dfs_autoswitch_des_chan; 1200 #endif 1201 enum wlan_phymode dfs_autoswitch_des_mode; 1202 #endif 1203 #ifdef WLAN_DFS_PRECAC_AUTO_CHAN_SUPPORT 1204 #ifdef CONFIG_CHAN_FREQ_API 1205 uint16_t dfs_precac_inter_chan_freq; 1206 uint16_t dfs_autoswitch_des_chan_freq; 1207 #endif 1208 #endif 1209 uint8_t dfs_pre_cac_timeout_channel_change:1; 1210 qdf_timer_t wlan_dfs_task_timer; 1211 int dur_multiplier; 1212 uint16_t wlan_dfs_isdfsregdomain; 1213 int wlan_dfs_false_rssi_thres; 1214 int wlan_dfs_peak_mag; 1215 struct dfs_event_log radar_log[DFS_EVENT_LOG_SIZE]; 1216 int dfs_event_log_count; 1217 int dfs_event_log_on; 1218 int dfs_phyerr_count; 1219 int dfs_phyerr_reject_count; 1220 int dfs_phyerr_queued_count; 1221 int dfs_phyerr_freq_min; 1222 int dfs_phyerr_freq_max; 1223 int dfs_phyerr_w53_counter; 1224 int dfs_pri_multiplier; 1225 int wlan_dfs_nol_timeout; 1226 bool update_nol; 1227 uint32_t dfs_seq_num; 1228 int dfs_nol_event[DFS_CHAN_MAX]; 1229 qdf_timer_t dfs_nol_timer; 1230 1231 TAILQ_HEAD(, dfs_nolelem) dfs_nol_free_list; 1232 qdf_work_t dfs_nol_elem_free_work; 1233 1234 qdf_timer_t dfs_cac_timer; 1235 qdf_timer_t dfs_cac_valid_timer; 1236 int dfs_cac_timeout_override; 1237 uint8_t dfs_enable:1, 1238 dfs_cac_timer_running:1, 1239 dfs_ignore_dfs:1, 1240 dfs_ignore_cac:1, 1241 dfs_cac_valid:1; 1242 uint32_t dfs_cac_valid_time; 1243 int dfs_precac_timeout_override; 1244 uint8_t dfs_num_precac_freqs; 1245 #if defined(WLAN_DFS_FULL_OFFLOAD) && defined(QCA_DFS_NOL_OFFLOAD) 1246 uint8_t dfs_disable_radar_marking; 1247 #endif 1248 TAILQ_HEAD(, dfs_precac_entry) dfs_precac_list; 1249 enum phy_ch_width dfs_precac_chwidth; 1250 1251 struct dfs_channel *dfs_curchan; 1252 struct dfs_channel *dfs_prevchan; 1253 struct dfs_channel dfs_cac_started_chan; 1254 struct wlan_objmgr_pdev *dfs_pdev_obj; 1255 struct dfs_soc_priv_obj *dfs_soc_obj; 1256 #if defined(QCA_SUPPORT_AGILE_DFS) || defined(ATH_SUPPORT_ZERO_CAC_DFS) 1257 uint8_t dfs_psoc_idx; 1258 #endif 1259 #ifdef CONFIG_CHAN_NUM_API 1260 uint8_t dfs_agile_precac_freq; 1261 #endif 1262 #ifdef CONFIG_CHAN_FREQ_API 1263 uint16_t dfs_agile_precac_freq_mhz; 1264 #endif 1265 bool dfs_is_offload_enabled; 1266 int dfs_use_nol; 1267 qdf_spinlock_t dfs_nol_lock; 1268 uint16_t tx_leakage_threshold; 1269 bool dfs_use_nol_subchannel_marking; 1270 uint8_t dfs_spoof_test_done:1; 1271 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 1272 qdf_timer_t dfs_host_wait_timer; 1273 uint32_t dfs_average_pri; 1274 uint32_t dfs_average_duration; 1275 uint32_t dfs_average_sidx; 1276 uint8_t dfs_is_host_wait_running:1, 1277 dfs_average_params_sent:1, 1278 dfs_no_res_from_fw:1, 1279 dfs_spoof_check_failed:1; 1280 struct dfs_channel dfs_radar_found_chan; 1281 int dfs_status_timeout_override; 1282 #endif 1283 bool dfs_is_stadfs_enabled; 1284 int32_t dfs_min_sidx; 1285 int32_t dfs_max_sidx; 1286 uint8_t dfs_seg_id; 1287 uint8_t dfs_is_chirp; 1288 bool dfs_bw_reduced; 1289 int32_t dfs_freq_offset; 1290 bool dfs_cac_aborted; 1291 qdf_spinlock_t dfs_data_struct_lock; 1292 uint8_t dfs_nol_ie_bandwidth; 1293 uint16_t dfs_nol_ie_startfreq; 1294 uint8_t dfs_nol_ie_bitmap; 1295 bool dfs_is_rcsa_ie_sent; 1296 bool dfs_is_nol_ie_sent; 1297 uint8_t dfs_legacy_precac_ucfg:1, 1298 dfs_agile_precac_ucfg:1, 1299 #if defined(QCA_SUPPORT_ADFS_RCAC) 1300 dfs_agile_rcac_ucfg:1, 1301 #endif 1302 dfs_fw_adfs_support_non_160:1, 1303 dfs_fw_adfs_support_160:1; 1304 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(WLAN_DFS_SYNTHETIC_RADAR) 1305 bool dfs_allow_hw_pulses; 1306 #endif 1307 struct dfs_mode_switch_defer_params dfs_defer_params; 1308 uint8_t dfs_agile_detector_id; 1309 #if defined(QCA_SUPPORT_ADFS_RCAC) 1310 uint16_t dfs_agile_rcac_freq_ucfg; 1311 struct dfs_rcac_params dfs_rcac_param; 1312 #endif 1313 uint16_t dfs_lowest_pri_limit; 1314 }; 1315 1316 #if defined(QCA_SUPPORT_AGILE_DFS) || defined(ATH_SUPPORT_ZERO_CAC_DFS) 1317 /** 1318 * struct wlan_dfs_priv - dfs private struct with agile capability info 1319 * @wlan_dfs: pointer to wlan_dfs object. 1320 * @agile_precac_active: agile precac active information for wlan_dfs_priv obj 1321 */ 1322 struct wlan_dfs_priv { 1323 struct wlan_dfs *dfs; 1324 bool agile_precac_active; 1325 }; 1326 #endif 1327 1328 /** 1329 * struct dfs_soc_priv_obj - dfs private data 1330 * @psoc: pointer to PSOC object information 1331 * @pdev: pointer to PDEV object information 1332 * @dfs_is_phyerr_filter_offload: For some chip like Rome indicates too many 1333 * phyerr packets in a short time, which causes 1334 * OS hang. If this feild is configured as true, 1335 * FW will do the pre-check, filter out some 1336 * kinds of invalid phyerrors and indicate 1337 * radar detection related information to host. 1338 * @dfs_priv: array of dfs private structs with agile capability info 1339 * @num_dfs_privs: array size of dfs private structs for given psoc. 1340 * @cur_precac_dfs_index: current precac dfs index 1341 * @dfs_precac_timer: agile precac timer 1342 * @dfs_precac_timer_running: precac timer running flag 1343 * @ocac_status: Off channel CAC complete status 1344 * @dfs_nol_ctx: dfs NOL data for all radios. 1345 * @dfs_rcac_timer: Agile RCAC (Rolling CAC) timer. 1346 * @dfs_rcac_sm_hdl: DFS Rolling CAC state machine handle. 1347 * @dfs_rcac_curr_state: Current state of DFS rolling CAC state machine. 1348 * @dfs_rcac_sm_lock: DFS Rolling CAC state machine lock. 1349 */ 1350 struct dfs_soc_priv_obj { 1351 struct wlan_objmgr_psoc *psoc; 1352 struct wlan_objmgr_pdev *pdev; 1353 bool dfs_is_phyerr_filter_offload; 1354 #if defined(QCA_SUPPORT_AGILE_DFS) || defined(ATH_SUPPORT_ZERO_CAC_DFS) 1355 struct wlan_dfs_priv dfs_priv[WLAN_UMAC_MAX_PDEVS]; 1356 uint8_t num_dfs_privs; 1357 uint8_t cur_precac_dfs_index; 1358 qdf_timer_t dfs_precac_timer; 1359 uint8_t dfs_precac_timer_running; 1360 bool precac_state_started; 1361 bool ocac_status; 1362 #endif 1363 struct dfsreq_nolinfo *dfs_psoc_nolinfo; 1364 #if defined(QCA_SUPPORT_ADFS_RCAC) 1365 qdf_timer_t dfs_rcac_timer; 1366 struct wlan_sm *dfs_rcac_sm_hdl; 1367 enum dfs_rcac_sm_state dfs_rcac_curr_state; 1368 qdf_spinlock_t dfs_rcac_sm_lock; 1369 #endif 1370 }; 1371 1372 /** 1373 * enum DFS debug - This should match the table from if_ath.c. 1374 * @WLAN_DEBUG_DFS: Minimal DFS debug. 1375 * @WLAN_DEBUG_DFS1: Normal DFS debug. 1376 * @WLAN_DEBUG_DFS2: Maximal DFS debug. 1377 * @WLAN_DEBUG_DFS3: Matched filterID display. 1378 * @WLAN_DEBUG_DFS_PHYERR: Phy error parsing. 1379 * @WLAN_DEBUG_DFS_NOL: NOL related entries. 1380 * @WLAN_DEBUG_DFS_PHYERR_SUM: PHY error summary. 1381 * @WLAN_DEBUG_DFS_PHYERR_PKT: PHY error payload. 1382 * @WLAN_DEBUG_DFS_BIN5: BIN5 checks. 1383 * @WLAN_DEBUG_DFS_BIN5_FFT: BIN5 FFT check. 1384 * @WLAN_DEBUG_DFS_BIN5_PULSE: BIN5 pulse check. 1385 * @WLAN_DEBUG_DFS_FALSE_DET: False detection debug related prints. 1386 * @WLAN_DEBUG_DFS_FALSE_DET2: Second level check to confirm poisitive 1387 * detection. 1388 * @WLAN_DEBUG_DFS_RANDOM_CHAN: Random channel selection. 1389 */ 1390 enum { 1391 WLAN_DEBUG_DFS = 0x00000100, 1392 WLAN_DEBUG_DFS1 = 0x00000200, 1393 WLAN_DEBUG_DFS2 = 0x00000400, 1394 WLAN_DEBUG_DFS3 = 0x00000800, 1395 WLAN_DEBUG_DFS_PHYERR = 0x00001000, 1396 WLAN_DEBUG_DFS_NOL = 0x00002000, 1397 WLAN_DEBUG_DFS_PHYERR_SUM = 0x00004000, 1398 WLAN_DEBUG_DFS_PHYERR_PKT = 0x00008000, 1399 WLAN_DEBUG_DFS_BIN5 = 0x00010000, 1400 WLAN_DEBUG_DFS_BIN5_FFT = 0x00020000, 1401 WLAN_DEBUG_DFS_BIN5_PULSE = 0x00040000, 1402 WLAN_DEBUG_DFS_FALSE_DET = 0x00080000, 1403 WLAN_DEBUG_DFS_FALSE_DET2 = 0x00100000, 1404 WLAN_DEBUG_DFS_RANDOM_CHAN = 0x00200000, 1405 WLAN_DEBUG_DFS_RCAC = 0x00400000, 1406 WLAN_DEBUG_DFS_MAX = 0x80000000, 1407 WLAN_DEBUG_DFS_ALWAYS = WLAN_DEBUG_DFS_MAX 1408 }; 1409 1410 /** 1411 * enum host dfs spoof check status. 1412 * @HOST_DFS_CHECK_PASSED: Host indicates RADAR detected and the FW 1413 * confirms it to be spoof radar to host. 1414 * @HOST_DFS_CHECK_FAILED: Host doesn't indicate RADAR detected or spoof 1415 * radar parameters by 1416 * WMI_HOST_DFS_RADAR_FOUND_CMDID doesn't match. 1417 * @HOST_DFS_STATUS_CHECK_HW_RADAR: Host indicates RADAR detected and the 1418 * FW confirms it to be real HW radar to host. 1419 */ 1420 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) && defined(HOST_DFS_SPOOF_TEST) 1421 enum { 1422 HOST_DFS_STATUS_CHECK_PASSED = 0, 1423 HOST_DFS_STATUS_CHECK_FAILED = 1, 1424 HOST_DFS_STATUS_CHECK_HW_RADAR = 2 1425 }; 1426 #endif 1427 1428 /** 1429 * struct dfs_phy_err - DFS phy error. 1430 * @fulltsf: 64-bit TSF as read from MAC. 1431 * @is_pri: Detected on primary channel. 1432 * @is_ext: Detected on extension channel. 1433 * @is_dc: Detected at DC. 1434 * @is_early: Early detect. 1435 * @do_check_chirp: Whether to check hw_chirp/sw_chirp. 1436 * @is_hw_chirp: Hardware-detected chirp. 1437 * @is_sw_chirp: Software detected chirp. 1438 * @rs_tstamp: 32 bit TSF from RX descriptor (event). 1439 * @freq: Centre frequency of event - KHz. 1440 * @freq_lo: Lower bounds of frequency - KHz. 1441 * @freq_hi: Upper bounds of frequency - KHz. 1442 * @rssi: Pulse RSSI. 1443 * @dur: Pulse duration, raw (not uS). 1444 * @seg_id: HT80_80/HT160 use. 1445 * @sidx: Seg index. 1446 * @freq_offset_khz: Freq offset in KHz. 1447 * @peak_mag: Peak mag. 1448 * @total_gain: Total gain. 1449 * @mb_gain: Mb gain. 1450 * @relpwr_db: Relpower in DB. 1451 * @pulse_delta_diff: Pulse delta diff. 1452 * @pulse_delta_peak: Pulse delta peak. 1453 * @pulse_psidx_diff: Pulse psidx diff. 1454 * 1455 * Chirp notes! 1456 * 1457 * Pre-Sowl chips don't do FFT reports, so chirp pulses simply show up 1458 * as long duration pulses. 1459 * 1460 * The bin5 checking code would simply look for a chirp pulse of the correct 1461 * duration (within MIN_BIN5_DUR and MAX_BIN5_DUR) and add it to the "chirp" 1462 * pattern. 1463 * 1464 * For Sowl and later, an FFT was done on longer duration frames. If those 1465 * frames looked like a chirp, their duration was adjusted to fall within 1466 * the chirp duration limits. If the pulse failed the chirp test (it had 1467 * no FFT data or the FFT didn't meet the chirping requirements) then the 1468 * pulse duration was adjusted to be greater than MAX_BIN5_DUR, so it 1469 * would always fail chirp detection. 1470 * 1471 * This is pretty horrible. 1472 * 1473 * The eventual goal for chirp handling is thus: 1474 * 1475 * 1)In case someone ever wants to do chirp detection with this code on 1476 * chips that don't support chirp detection, you can still do it based 1477 * on pulse duration. That's your problem to solve. 1478 * 1479 * 2)For chips that do hardware chirp detection or FFT, the "do_check_chirp" 1480 * bit should be set. 1481 * 1482 * 3)Then, either is_hw_chirp or is_sw_chirp is set, indicating that 1483 * the hardware or software post-processing of the chirp event found 1484 * that indeed it was a chirp. 1485 * 1486 * 4)Finally, the bin5 code should just check whether the chirp bits are 1487 * set and behave appropriately, falling back onto the duration checks 1488 * if someone wishes to use this on older hardware (or with disabled 1489 * FFTs, for whatever reason.) 1490 * 1491 * XXX TODO: 1492 * 1493 * 1)add duration in uS and raw duration, so the PHY error parsing 1494 * code is responsible for doing the duration calculation; 1495 * 2)add ts in raw and corrected, so the PHY error parsing 1496 * code is responsible for doing the offsetting, not the radar 1497 * event code. 1498 */ 1499 struct dfs_phy_err { 1500 uint64_t fulltsf; 1501 uint32_t is_pri:1, 1502 is_ext:1, 1503 is_dc:1, 1504 is_early:1, 1505 do_check_chirp:1, 1506 is_hw_chirp:1, 1507 is_sw_chirp:1; 1508 uint32_t rs_tstamp; 1509 uint32_t freq; 1510 uint32_t freq_lo; 1511 uint32_t freq_hi; 1512 uint8_t rssi; 1513 uint8_t dur; 1514 uint8_t seg_id; 1515 int sidx; 1516 u_int freq_offset_khz; 1517 int peak_mag; 1518 int total_gain; 1519 int mb_gain; 1520 int relpwr_db; 1521 uint8_t pulse_delta_diff; 1522 int8_t pulse_delta_peak; 1523 int16_t pulse_psidx_diff; 1524 }; 1525 1526 /** 1527 * struct rx_radar_status - Parsed radar status 1528 * @raw_tsf: Raw tsf 1529 * @tsf_offset: TSF offset. 1530 * @rssi: RSSI. 1531 * @pulse_duration: Pulse duration. 1532 * @is_chirp: Is chirp. 1533 * @delta_peak: Delta peak. 1534 * @delta_diff: Delta diff. 1535 * @sidx: Starting frequency. 1536 * @freq_offset: Frequency offset. 1537 * @agc_total_gain: AGC total gain. 1538 * @agc_mb_gain: AGC MB gain. 1539 */ 1540 struct rx_radar_status { 1541 uint32_t raw_tsf; 1542 uint32_t tsf_offset; 1543 int rssi; 1544 int pulse_duration; 1545 int is_chirp:1; 1546 int delta_peak; 1547 int delta_diff; 1548 int sidx; 1549 int freq_offset; /* in KHz */ 1550 int agc_total_gain; 1551 int agc_mb_gain; 1552 }; 1553 1554 /** 1555 * struct rx_search_fft_report - FFT report. 1556 * @total_gain_db: Total gain in Db. 1557 * @base_pwr_db: Base power in Db. 1558 * @fft_chn_idx: FFT channel index. 1559 * @peak_sidx: Peak sidx. 1560 * @relpwr_db: Real power in Db. 1561 * @avgpwr_db: Average power in Db. 1562 * @peak_mag: Peak Mag. 1563 * @num_str_bins_ib: Num dtr BINs IB 1564 * @seg_id: Segment ID 1565 */ 1566 struct rx_search_fft_report { 1567 uint32_t total_gain_db; 1568 uint32_t base_pwr_db; 1569 int fft_chn_idx; 1570 int peak_sidx; 1571 int relpwr_db; 1572 int avgpwr_db; 1573 int peak_mag; 1574 int num_str_bins_ib; 1575 int seg_id; 1576 }; 1577 1578 /** 1579 * dfs_process_radarevent() - process the radar event generated for a pulse. 1580 * @dfs: Pointer to wlan_dfs structure. 1581 * @chan: Current channel. 1582 * 1583 * There is currently no way to specify that a radar event has occurred on 1584 * a specific channel, so the current methodology is to mark both the pri 1585 * and ext channels as being unavailable. This should be fixed for 802.11ac 1586 * or we'll quickly run out of valid channels to use. 1587 * 1588 * If Radar found, this marks the channel (and the extension channel, if HT40) 1589 * as having seen a radar event. It marks CHAN_INTERFERENCE and will add it to 1590 * the local NOL implementation. This is only done for 'usenol=1', as the other 1591 * two modes don't do radar notification or CAC/CSA/NOL; it just notes there 1592 * was a radar. 1593 */ 1594 void dfs_process_radarevent(struct wlan_dfs *dfs, 1595 struct dfs_channel *chan); 1596 1597 /** 1598 * dfs_nol_addchan() - Add channel to NOL. 1599 * @dfs: Pointer to wlan_dfs structure. 1600 * @freq: frequency to add to NOL. 1601 * @dfs_nol_timeout: NOL timeout. 1602 */ 1603 void dfs_nol_addchan(struct wlan_dfs *dfs, 1604 uint16_t freq, 1605 uint32_t dfs_nol_timeout); 1606 1607 /** 1608 * dfs_get_nol() - Get NOL. 1609 * @dfs: Pointer to wlan_dfs structure. 1610 * @dfs_nol: Pointer to dfsreq_nolelem structure to save the channels from NOL. 1611 * @nchan: Number of channels. 1612 */ 1613 void dfs_get_nol(struct wlan_dfs *dfs, 1614 struct dfsreq_nolelem *dfs_nol, 1615 int *nchan); 1616 1617 /** 1618 * dfs_set_nol() - Set NOL. 1619 * @dfs: Pointer to wlan_dfs structure. 1620 * @dfs_nol: Pointer to dfsreq_nolelem structure. 1621 * @nchan: Number of channels. 1622 */ 1623 void dfs_set_nol(struct wlan_dfs *dfs, 1624 struct dfsreq_nolelem *dfs_nol, 1625 int nchan); 1626 1627 /** 1628 * dfs_nol_update() - NOL update 1629 * @dfs: Pointer to wlan_dfs structure. 1630 * 1631 * Notify the driver/umac that it should update the channel radar/NOL flags 1632 * based on the current NOL list. 1633 */ 1634 void dfs_nol_update(struct wlan_dfs *dfs); 1635 1636 /** 1637 * dfs_nol_timer_cleanup() - NOL timer cleanup. 1638 * @dfs: Pointer to wlan_dfs structure. 1639 * 1640 * Cancels the NOL timer and frees the NOL elements. 1641 */ 1642 void dfs_nol_timer_cleanup(struct wlan_dfs *dfs); 1643 1644 /** 1645 * dfs_nol_timer_detach() - Free NOL timer. 1646 * @dfs: Pointer to wlan_dfs structure. 1647 */ 1648 void dfs_nol_timer_detach(struct wlan_dfs *dfs); 1649 1650 /** 1651 * dfs_nol_workqueue_cleanup() - Flushes NOL workqueue. 1652 * @dfs: Pointer to wlan_dfs structure. 1653 * 1654 * Flushes the NOL workqueue. 1655 */ 1656 void dfs_nol_workqueue_cleanup(struct wlan_dfs *dfs); 1657 1658 /** 1659 * dfs_retain_bin5_burst_pattern() - Retain the BIN5 burst pattern. 1660 * @dfs: Pointer to wlan_dfs structure. 1661 * @diff_ts: Timestamp diff. 1662 * @old_dur: Old duration. 1663 */ 1664 uint8_t dfs_retain_bin5_burst_pattern(struct wlan_dfs *dfs, 1665 uint32_t diff_ts, 1666 uint8_t old_dur); 1667 1668 /** 1669 * dfs_bin5_check_pulse() - BIN5 check pulse. 1670 * @dfs: Pointer to wlan_dfs structure. 1671 * @re: Pointer to dfs_event structure. 1672 * @br: Pointer to dfs_bin5radars structure. 1673 * 1674 * Reject the pulse if: 1675 * 1) It's outside the RSSI threshold; 1676 * 2) It's outside the pulse duration; 1677 * 3) It's been verified by HW/SW chirp checking 1678 * and neither of those found a chirp. 1679 */ 1680 int dfs_bin5_check_pulse(struct wlan_dfs *dfs, 1681 struct dfs_event *re, 1682 struct dfs_bin5radars *br); 1683 1684 /** 1685 * dfs_bin5_addpulse() - BIN5 add pulse. 1686 * @dfs: Pointer to wlan_dfs structure. 1687 * @br: Pointer to dfs_bin5radars structure. 1688 * @re: Pointer to dfs_event structure. 1689 * @thists: Timestamp. 1690 */ 1691 int dfs_bin5_addpulse(struct wlan_dfs *dfs, 1692 struct dfs_bin5radars *br, 1693 struct dfs_event *re, 1694 uint64_t thists); 1695 1696 /** 1697 * dfs_bin5_check() - BIN5 check. 1698 * @dfs: Pointer to wlan_dfs structure. 1699 * 1700 * If the dfs structure is NULL (which should be illegal if everyting is working 1701 * properly, then signify that a bin5 radar was found. 1702 */ 1703 int dfs_bin5_check(struct wlan_dfs *dfs); 1704 1705 /** 1706 * dfs_check_chirping() - Check chirping. 1707 * @dfs: Pointer to wlan_dfs structure. 1708 * @buf: Phyerr buffer 1709 * @datalen: Phyerr buf length 1710 * @is_ctl: detected on primary channel. 1711 * @is_ext: detected on extension channel. 1712 * @slope: Slope 1713 * @is_dc: DC found 1714 * 1715 * This examines the FFT data contained in the PHY error information to figure 1716 * out whether the pulse is moving across frequencies. 1717 */ 1718 int dfs_check_chirping(struct wlan_dfs *dfs, 1719 void *buf, 1720 uint16_t datalen, 1721 int is_ctl, 1722 int is_ext, 1723 int *slope, 1724 int *is_dc); 1725 1726 /** 1727 * dfs_get_random_bin5_dur() - Get random BIN5 duration. 1728 * @dfs: Pointer to wlan_dfs structure. 1729 * @tstamp: Timestamp. 1730 * 1731 * Chirping pulses may get cut off at DC and report lower durations. 1732 * This function will compute a suitable random duration for each pulse. 1733 * Duration must be between 50 and 100 us, but remember that in 1734 * wlan_process_phyerr() which calls this function, we are dealing with the 1735 * HW reported duration (unconverted). dfs_process_radarevent() will 1736 * actually convert the duration into the correct value. 1737 * This function doesn't take into account whether the hardware 1738 * is operating in 5GHz fast clock mode or not. 1739 * And this function doesn't take into account whether the hardware 1740 * is peregrine or not. 1741 */ 1742 int dfs_get_random_bin5_dur(struct wlan_dfs *dfs, 1743 uint64_t tstamp); 1744 1745 /** 1746 * dfs_print_delayline() - Prints delayline. 1747 * @dfs: Pointer to wlan_dfs structure. 1748 * @dl: Pointer to dfs_delayline structure. 1749 */ 1750 void dfs_print_delayline(struct wlan_dfs *dfs, 1751 struct dfs_delayline *dl); 1752 1753 /** 1754 * dfs_print_nol() - Print NOL elements. 1755 * @dfs: Pointer to wlan_dfs structure. 1756 */ 1757 void dfs_print_nol(struct wlan_dfs *dfs); 1758 1759 /** 1760 * dfs_print_filter() - Prints the filter. 1761 * @dfs: Pointer to wlan_dfs structure. 1762 * @rf: Pointer to dfs_filter structure. 1763 */ 1764 void dfs_print_filter(struct wlan_dfs *dfs, 1765 struct dfs_filter *rf); 1766 1767 /** 1768 * dfs_getchanstate() - Get chan state. 1769 * @dfs: Pointer to wlan_dfs structure. 1770 * @index: To save the index of dfs_radar[] 1771 * @ext_chan_flag: Extension channel flag; 1772 */ 1773 struct dfs_state *dfs_getchanstate(struct wlan_dfs *dfs, 1774 uint8_t *index, 1775 int ext_ch_flag); 1776 1777 /** 1778 * dfs_round() - DFS found. 1779 * @val: Convert durations to TSF ticks. 1780 * 1781 * Return: TSF ticks. 1782 */ 1783 uint32_t dfs_round(int32_t val); 1784 1785 /** 1786 * dfs_reset_alldelaylines() - Reset alldelaylines. 1787 * @dfs: Pointer to wlan_dfs structure. 1788 */ 1789 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 1790 void dfs_reset_alldelaylines(struct wlan_dfs *dfs); 1791 #else 1792 static inline void dfs_reset_alldelaylines(struct wlan_dfs *dfs) 1793 { 1794 } 1795 #endif 1796 1797 /** 1798 * dfs_reset_delayline() - Clear only a single delay line. 1799 * @dl: Pointer to dfs_delayline structure. 1800 */ 1801 void dfs_reset_delayline(struct dfs_delayline *dl); 1802 1803 /** 1804 * dfs_reset_filter_delaylines() - Reset filter delaylines. 1805 * @dft: Pointer to dfs_filtertype structure. 1806 */ 1807 void dfs_reset_filter_delaylines(struct dfs_filtertype *dft); 1808 1809 /** 1810 * dfs_reset_radarq() - Reset radar queue. 1811 * @dfs: Pointer to wlan_dfs structure. 1812 */ 1813 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 1814 void dfs_reset_radarq(struct wlan_dfs *dfs); 1815 #else 1816 static inline void dfs_reset_radarq(struct wlan_dfs *dfs) 1817 { 1818 } 1819 #endif 1820 1821 /** 1822 * dfs_add_pulse() - Adds pulse to the queue. 1823 * @dfs: Pointer to wlan_dfs structure. 1824 * @rf: Pointer to dfs_filter structure. 1825 * @re: Pointer to dfs_event structure. 1826 * @deltaT: deltaT value. 1827 * @this_ts: Last time stamp. 1828 */ 1829 void dfs_add_pulse(struct wlan_dfs *dfs, 1830 struct dfs_filter *rf, 1831 struct dfs_event *re, 1832 uint32_t deltaT, 1833 uint64_t this_ts); 1834 1835 /** 1836 * dfs_bin_check() - BIN check 1837 * @dfs: Pointer to wlan_dfs structure. 1838 * @rf: Pointer to dfs_filter structure. 1839 * @deltaT: deltaT value. 1840 * @width: Width 1841 * @ext_chan_flag: Extension channel flag. 1842 */ 1843 int dfs_bin_check(struct wlan_dfs *dfs, 1844 struct dfs_filter *rf, 1845 uint32_t deltaT, 1846 uint32_t dur, 1847 int ext_chan_flag); 1848 1849 /** 1850 * dfs_bin_pri_check() - BIN PRI check 1851 * @dfs: Pointer to wlan_dfs structure. 1852 * @rf: Pointer to dfs_filter structure. 1853 * @dl: Pointer to dfs_delayline structure. 1854 * @score: Primary score. 1855 * @refpri: Current "filter" time for start of pulse in usecs. 1856 * @refdur: Duration value. 1857 * @ext_chan_flag: Extension channel flag. 1858 * @fundamentalpri: Highest PRI. 1859 */ 1860 int dfs_bin_pri_check(struct wlan_dfs *dfs, 1861 struct dfs_filter *rf, 1862 struct dfs_delayline *dl, 1863 uint32_t score, 1864 uint32_t refpri, 1865 uint32_t refdur, 1866 int ext_chan_flag, 1867 int fundamentalpri); 1868 1869 /** 1870 * dfs_staggered_check() - Detection implementation for staggered PRIs. 1871 * @dfs: Pointer to wlan_dfs structure. 1872 * @rf: Pointer to dfs_filter structure. 1873 * @deltaT: Delta of the Timestamp. 1874 * @width: Duration of radar pulse. 1875 * 1876 * Return: 1 on success and 0 on failure. 1877 */ 1878 int dfs_staggered_check(struct wlan_dfs *dfs, 1879 struct dfs_filter *rf, 1880 uint32_t deltaT, 1881 uint32_t width); 1882 1883 /** 1884 * dfs_get_pri_margin() - Get Primary margin. 1885 * @dfs: Pointer to wlan_dfs structure. 1886 * @is_extchan_detect: Extension channel detect. 1887 * @is_fixed_pattern: Fixed pattern. 1888 * 1889 * For the extension channel, if legacy traffic is present, we see a lot of 1890 * false alarms, so make the PRI margin narrower depending on the busy % for 1891 * the extension channel. 1892 * 1893 * Return: Returns pri_margin. 1894 */ 1895 int dfs_get_pri_margin(struct wlan_dfs *dfs, 1896 int is_extchan_detect, 1897 int is_fixed_pattern); 1898 1899 /** 1900 * dfs_get_filter_threshold() - Get filter threshold. 1901 * @dfs: Pointer to wlan_dfs structure. 1902 * @rf: Pointer to dfs_filter structure. 1903 * @is_extchan_detect: Extension channel detect. 1904 * 1905 * For the extension channel, if legacy traffic is present, we see a lot of 1906 * false alarms, so make the thresholds higher depending on the busy % for the 1907 * extension channel. 1908 * 1909 * Return: Returns threshold. 1910 */ 1911 int dfs_get_filter_threshold(struct wlan_dfs *dfs, 1912 struct dfs_filter *rf, 1913 int is_extchan_detect); 1914 1915 #if defined(QCA_MCL_DFS_SUPPORT) 1916 /** 1917 * dfs_process_ar_event() - Process the ar event. 1918 * @dfs: Pointer to wlan_dfs structure. 1919 * @chan: Current channel structure. 1920 */ 1921 static inline void dfs_process_ar_event(struct wlan_dfs *dfs, 1922 struct dfs_channel *chan) 1923 { 1924 } 1925 1926 /** 1927 * dfs_reset_ar() - resets the ar state. 1928 * @dfs: pointer to wlan_dfs structure. 1929 */ 1930 static inline void dfs_reset_ar(struct wlan_dfs *dfs) 1931 { 1932 } 1933 1934 /** 1935 * dfs_reset_arq() - resets the ar queue. 1936 * @dfs: pointer to wlan_dfs structure. 1937 */ 1938 static inline void dfs_reset_arq(struct wlan_dfs *dfs) 1939 { 1940 } 1941 1942 #else 1943 void dfs_process_ar_event(struct wlan_dfs *dfs, 1944 struct dfs_channel *chan); 1945 1946 void dfs_reset_ar(struct wlan_dfs *dfs); 1947 void dfs_reset_arq(struct wlan_dfs *dfs); 1948 #endif 1949 1950 /** 1951 * dfs_is_radar_enabled() - check if radar detection is enabled. 1952 * @dfs: Pointer to wlan_dfs structure. 1953 * @ignore_dfs: if 1 then radar detection is disabled.. 1954 */ 1955 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 1956 void dfs_is_radar_enabled(struct wlan_dfs *dfs, 1957 int *ignore_dfs); 1958 #else 1959 static inline void dfs_is_radar_enabled(struct wlan_dfs *dfs, 1960 int *ignore_dfs) 1961 { 1962 } 1963 #endif 1964 1965 /** 1966 * dfs_process_phyerr_bb_tlv() - Parses the PHY error and populates the 1967 * dfs_phy_err struct. 1968 * @dfs: Pointer to wlan_dfs structure. 1969 * @buf: Phyerr buffer 1970 * @datalen: Phyerr buf len 1971 * @rssi: RSSI 1972 * @ext_rssi: Extension RSSI. 1973 * @rs_tstamp: Time stamp. 1974 * @fulltsf: TSF64. 1975 * @e: Pointer to dfs_phy_err structure. 1976 * 1977 * Return: Returns 1. 1978 */ 1979 int dfs_process_phyerr_bb_tlv(struct wlan_dfs *dfs, 1980 void *buf, 1981 uint16_t datalen, 1982 uint8_t rssi, 1983 uint8_t ext_rssi, 1984 uint32_t rs_tstamp, 1985 uint64_t fulltsf, 1986 struct dfs_phy_err *e); 1987 1988 /** 1989 * dfs_reset() - DFS reset 1990 * @dfs: Pointer to wlan_dfs structure. 1991 */ 1992 void dfs_reset(struct wlan_dfs *dfs); 1993 1994 /** 1995 * dfs_radar_enable() - Enables the radar. 1996 * @dfs: Pointer to wlan_dfs structure. 1997 * @no_cac: If no_cac is 0, it cancels the CAC. 1998 */ 1999 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 2000 void dfs_radar_enable(struct wlan_dfs *dfs, 2001 int no_cac, uint32_t opmode); 2002 #else 2003 static inline void dfs_radar_enable(struct wlan_dfs *dfs, 2004 int no_cac, uint32_t opmode) 2005 { 2006 } 2007 #endif 2008 2009 /** 2010 * dfs_process_phyerr() - Process phyerr. 2011 * @dfs: Pointer to wlan_dfs structure. 2012 * @buf: Phyerr buffer. 2013 * @datalen: phyerr buffer length. 2014 * @r_rssi: RSSI. 2015 * @r_ext_rssi: Extension channel RSSI. 2016 * @r_rs_tstamp: Timestamp. 2017 * @r_fulltsf: TSF64. 2018 */ 2019 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 2020 void dfs_process_phyerr(struct wlan_dfs *dfs, 2021 void *buf, 2022 uint16_t datalen, 2023 uint8_t r_rssi, 2024 uint8_t r_ext_rssi, 2025 uint32_t r_rs_tstamp, 2026 uint64_t r_fulltsf); 2027 #else 2028 static inline void dfs_process_phyerr(struct wlan_dfs *dfs, 2029 void *buf, 2030 uint16_t datalen, 2031 uint8_t r_rssi, 2032 uint8_t r_ext_rssi, 2033 uint32_t r_rs_tstamp, 2034 uint64_t r_fulltsf) 2035 { 2036 } 2037 #endif 2038 2039 #ifdef QCA_MCL_DFS_SUPPORT 2040 /** 2041 * dfs_process_phyerr_filter_offload() - Process radar event. 2042 * @dfs: Pointer to wlan_dfs structure. 2043 * @wlan_radar_event: Pointer to radar_event_info structure. 2044 * 2045 * Return: None 2046 */ 2047 #if defined(WLAN_DFS_PARTIAL_OFFLOAD) 2048 void dfs_process_phyerr_filter_offload(struct wlan_dfs *dfs, 2049 struct radar_event_info *wlan_radar_event); 2050 #else 2051 static inline void dfs_process_phyerr_filter_offload( 2052 struct wlan_dfs *dfs, 2053 struct radar_event_info *wlan_radar_event) 2054 { 2055 } 2056 #endif 2057 #endif 2058 2059 /** 2060 * dfs_get_radars() - Based on the chipset, calls init radar table functions. 2061 * @dfs: Pointer to wlan_dfs structure. 2062 */ 2063 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 2064 void dfs_get_radars(struct wlan_dfs *dfs); 2065 #else 2066 static inline void dfs_get_radars(struct wlan_dfs *dfs) 2067 { 2068 } 2069 #endif 2070 2071 /** 2072 * dfs_attach() - Wrapper function to allocate memory for wlan_dfs members. 2073 * @dfs: Pointer to wlan_dfs structure. 2074 */ 2075 int dfs_attach(struct wlan_dfs *dfs); 2076 2077 2078 /** 2079 * dfs_create_object() - Creates DFS object. 2080 * @dfs: Pointer to wlan_dfs structure. 2081 */ 2082 int dfs_create_object(struct wlan_dfs **dfs); 2083 2084 /** 2085 * dfs_destroy_object() - Destroys the DFS object. 2086 * @dfs: Pointer to wlan_dfs structure. 2087 */ 2088 void dfs_destroy_object(struct wlan_dfs *dfs); 2089 2090 /** 2091 * dfs_detach() - Wrapper function to free dfs variables. 2092 * @dfs: Pointer to wlan_dfs structure. 2093 */ 2094 void dfs_detach(struct wlan_dfs *dfs); 2095 2096 /** 2097 * dfs_cac_valid_reset() - Cancels the dfs_cac_valid_timer timer. 2098 * @dfs: Pointer to wlan_dfs structure. 2099 * @prevchan_ieee: Prevchan number. 2100 * @prevchan_flags: Prevchan flags. 2101 */ 2102 #ifdef CONFIG_CHAN_NUM_API 2103 void dfs_cac_valid_reset(struct wlan_dfs *dfs, 2104 uint8_t prevchan_ieee, 2105 uint32_t prevchan_flags); 2106 #endif 2107 2108 /** 2109 * dfs_cac_valid_reset_for_freq() - Cancels the dfs_cac_valid_timer timer. 2110 * @dfs: Pointer to wlan_dfs structure. 2111 * @prevchan_chan: Prevchan frequency 2112 * @prevchan_flags: Prevchan flags. 2113 */ 2114 #ifdef CONFIG_CHAN_FREQ_API 2115 void dfs_cac_valid_reset_for_freq(struct wlan_dfs *dfs, 2116 uint16_t prevchan_freq, 2117 uint32_t prevchan_flags); 2118 #endif 2119 2120 /** 2121 * dfs_cac_stop() - Clear the AP CAC timer. 2122 * @dfs: Pointer to wlan_dfs structure. 2123 */ 2124 void dfs_cac_stop(struct wlan_dfs *dfs); 2125 2126 /** 2127 * dfs_cancel_cac_timer() - Cancels the CAC timer. 2128 * @dfs: Pointer to wlan_dfs structure. 2129 */ 2130 void dfs_cancel_cac_timer(struct wlan_dfs *dfs); 2131 2132 /** 2133 * dfs_start_cac_timer() - Starts the CAC timer. 2134 * @dfs: Pointer to wlan_dfs structure. 2135 */ 2136 void dfs_start_cac_timer(struct wlan_dfs *dfs); 2137 2138 /** 2139 * dfs_set_update_nol_flag() - Sets update_nol flag. 2140 * @dfs: Pointer to wlan_dfs structure. 2141 * @val: update_nol flag. 2142 */ 2143 void dfs_set_update_nol_flag(struct wlan_dfs *dfs, 2144 bool val); 2145 2146 /** 2147 * dfs_get_update_nol_flag() - Returns update_nol flag. 2148 * @dfs: Pointer to wlan_dfs structure. 2149 */ 2150 bool dfs_get_update_nol_flag(struct wlan_dfs *dfs); 2151 2152 /** 2153 * dfs_get_use_nol() - Get usenol. 2154 * @dfs: Pointer to wlan_dfs structure. 2155 */ 2156 int dfs_get_use_nol(struct wlan_dfs *dfs); 2157 2158 /** 2159 * dfs_get_nol_timeout() - Get NOL timeout. 2160 * @dfs: Pointer to wlan_dfs structure. 2161 */ 2162 int dfs_get_nol_timeout(struct wlan_dfs *dfs); 2163 2164 /** 2165 * dfs_is_ap_cac_timer_running() - Returns the dfs cac timer. 2166 * @dfs: Pointer to wlan_dfs structure. 2167 */ 2168 int dfs_is_ap_cac_timer_running(struct wlan_dfs *dfs); 2169 2170 /** 2171 * dfs_control()- Used to process ioctls related to DFS. 2172 * @dfs: Pointer to wlan_dfs structure. 2173 * @id: Command type. 2174 * @indata: Input buffer. 2175 * @insize: size of the input buffer. 2176 * @outdata: A buffer for the results. 2177 * @outsize: Size of the output buffer. 2178 */ 2179 int dfs_control(struct wlan_dfs *dfs, 2180 u_int id, 2181 void *indata, 2182 uint32_t insize, 2183 void *outdata, 2184 uint32_t *outsize); 2185 2186 /** 2187 * dfs_getnol() - Wrapper function for dfs_get_nol() 2188 * @dfs: Pointer to wlan_dfs structure. 2189 * @dfs_nolinfo: Pointer to dfsreq_nolinfo structure. 2190 */ 2191 void dfs_getnol(struct wlan_dfs *dfs, 2192 void *dfs_nolinfo); 2193 2194 /** 2195 * dfs_get_override_cac_timeout() - Get override CAC timeout value. 2196 * @dfs: Pointer to DFS object. 2197 * @cac_timeout: Pointer to save the CAC timeout value. 2198 */ 2199 int dfs_get_override_cac_timeout(struct wlan_dfs *dfs, 2200 int *cac_timeout); 2201 2202 /** 2203 * dfs_override_cac_timeout() - Override the default CAC timeout. 2204 * @dfs: Pointer to DFS object. 2205 * @cac_timeout: CAC timeout value. 2206 */ 2207 int dfs_override_cac_timeout(struct wlan_dfs *dfs, 2208 int cac_timeout); 2209 2210 /** 2211 * dfs_clear_nolhistory() - unmarks WLAN_CHAN_CLR_HISTORY_RADAR flag for 2212 * all the channels in dfs_ch_channels. 2213 * @dfs: Pointer to wlan_dfs structure. 2214 */ 2215 #if !defined(QCA_MCL_DFS_SUPPORT) 2216 void dfs_clear_nolhistory(struct wlan_dfs *dfs); 2217 #else 2218 static inline void 2219 dfs_clear_nolhistory(struct wlan_dfs *dfs) 2220 { 2221 } 2222 #endif 2223 2224 /** 2225 * ol_if_dfs_configure() - Initialize the RADAR table for offload chipsets. 2226 * @dfs: Pointer to wlan_dfs structure. 2227 * 2228 * This is called during a channel change or regulatory domain 2229 * reset; in order to fetch the new configuration information and 2230 * program the DFS pattern matching module. 2231 * 2232 * Eventually this should be split into "fetch config" (which can 2233 * happen at regdomain selection time) and "configure DFS" (which 2234 * can happen at channel config time) so as to minimise overheads 2235 * when doing channel changes. However, this'll do for now. 2236 */ 2237 void ol_if_dfs_configure(struct wlan_dfs *dfs); 2238 2239 /** 2240 * dfs_init_radar_filters() - Init Radar filters. 2241 * @dfs: Pointer to wlan_dfs structure. 2242 * @radar_info: Pointer to wlan_dfs_radar_tab_info structure. 2243 */ 2244 int dfs_init_radar_filters(struct wlan_dfs *dfs, 2245 struct wlan_dfs_radar_tab_info *radar_info); 2246 2247 /** 2248 * dfs_get_radars_for_ar5212() - Initialize radar table for AR5212 chipsets. 2249 * @dfs: Pointer to wlan_dfs structure. 2250 */ 2251 void dfs_get_radars_for_ar5212(struct wlan_dfs *dfs); 2252 2253 /** 2254 * dfs_get_radars_for_ar5416() - Initialize radar table for AR5416 chipsets. 2255 * @dfs: Pointer to wlan_dfs structure. 2256 */ 2257 void dfs_get_radars_for_ar5416(struct wlan_dfs *dfs); 2258 2259 /** 2260 * dfs_get_radars_for_ar9300() - Initialize radar table for AR9300 chipsets. 2261 * @dfs: Pointer to wlan_dfs structure. 2262 */ 2263 void dfs_get_radars_for_ar9300(struct wlan_dfs *dfs); 2264 2265 /** 2266 * dfs_print_filters() - Print the filters. 2267 * @dfs: Pointer to wlan_dfs structure. 2268 */ 2269 void dfs_print_filters(struct wlan_dfs *dfs); 2270 2271 /** 2272 * dfs_clear_stats() - Clear stats. 2273 * @dfs: Pointer to wlan_dfs structure. 2274 */ 2275 void dfs_clear_stats(struct wlan_dfs *dfs); 2276 2277 /** 2278 * dfs_radar_disable() - Disables the radar. 2279 * @dfs: Pointer to wlan_dfs structure. 2280 */ 2281 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 2282 int dfs_radar_disable(struct wlan_dfs *dfs); 2283 #else 2284 static inline int dfs_radar_disable(struct wlan_dfs *dfs) 2285 { 2286 return 0; 2287 } 2288 #endif 2289 2290 /** 2291 * dfs_get_debug_info() - Get debug info. 2292 * @dfs: Pointer to wlan_dfs structure. 2293 * @data: void pointer to the data to save dfs_proc_phyerr. 2294 */ 2295 int dfs_get_debug_info(struct wlan_dfs *dfs, 2296 void *data); 2297 2298 /** 2299 * dfs_cac_timer_attach() - Initialize cac timers. 2300 * @dfs: Pointer to wlan_dfs structure. 2301 */ 2302 void dfs_cac_timer_attach(struct wlan_dfs *dfs); 2303 2304 /** 2305 * dfs_cac_timer_reset() - Cancel dfs cac timers. 2306 * @dfs: Pointer to wlan_dfs structure. 2307 */ 2308 void dfs_cac_timer_reset(struct wlan_dfs *dfs); 2309 2310 /** 2311 * dfs_cac_timer_detach() - Free dfs cac timers. 2312 * @dfs: Pointer to wlan_dfs structure. 2313 */ 2314 void dfs_cac_timer_detach(struct wlan_dfs *dfs); 2315 2316 /** 2317 * dfs_nol_timer_init() - Initialize NOL timers. 2318 * @dfs: Pointer to wlan_dfs structure. 2319 */ 2320 void dfs_nol_timer_init(struct wlan_dfs *dfs); 2321 2322 /** 2323 * dfs_nol_attach() - Initialize NOL variables. 2324 * @dfs: Pointer to wlan_dfs structure. 2325 */ 2326 void dfs_nol_attach(struct wlan_dfs *dfs); 2327 2328 /** 2329 * dfs_nol_detach() - Detach NOL variables. 2330 * @dfs: Pointer to wlan_dfs structure. 2331 */ 2332 void dfs_nol_detach(struct wlan_dfs *dfs); 2333 2334 /** 2335 * dfs_print_nolhistory() - Print NOL history. 2336 * @dfs: Pointer to wlan_dfs structure. 2337 */ 2338 void dfs_print_nolhistory(struct wlan_dfs *dfs); 2339 2340 /** 2341 * dfs_stacac_stop() - Clear the STA CAC timer. 2342 * @dfs: Pointer to wlan_dfs structure. 2343 */ 2344 void dfs_stacac_stop(struct wlan_dfs *dfs); 2345 2346 /** 2347 * dfs_find_precac_secondary_vht80_chan() - Get a VHT80 channel with the 2348 * precac primary center frequency. 2349 * @dfs: Pointer to wlan_dfs structure. 2350 * @chan: Pointer to dfs channel structure. 2351 */ 2352 void dfs_find_precac_secondary_vht80_chan(struct wlan_dfs *dfs, 2353 struct dfs_channel *chan); 2354 2355 #ifdef WLAN_DFS_PRECAC_AUTO_CHAN_SUPPORT 2356 /** 2357 * dfs_precac_csa() - Automatically switch the channel to the DFS channel 2358 * on which PreCAC was completed without finding a RADAR. 2359 * Use CSA with TBTT_COUNT to switch the channel. 2360 * @dfs: Pointer to dfs handler. 2361 * 2362 * Return: Void 2363 */ 2364 void dfs_precac_csa(struct wlan_dfs *dfs); 2365 #endif 2366 2367 /** 2368 * dfs_phyerr_param_copy() - Function to copy src buf to dest buf. 2369 * @dst: dest buf. 2370 * @src: src buf. 2371 */ 2372 void dfs_phyerr_param_copy(struct wlan_dfs_phyerr_param *dst, 2373 struct wlan_dfs_phyerr_param *src); 2374 2375 /** 2376 * dfs_get_thresholds() - Get the threshold value. 2377 * @dfs: Pointer to wlan_dfs structure. 2378 * @param: Pointer to wlan_dfs_phyerr_param structure. 2379 */ 2380 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 2381 int dfs_get_thresholds(struct wlan_dfs *dfs, 2382 struct wlan_dfs_phyerr_param *param); 2383 #else 2384 static inline int dfs_get_thresholds(struct wlan_dfs *dfs, 2385 struct wlan_dfs_phyerr_param *param) 2386 { 2387 return 0; 2388 } 2389 #endif 2390 2391 /** 2392 * dfs_set_thresholds() - Sets the threshold value. 2393 * @dfs: Pointer to wlan_dfs structure. 2394 * @threshtype: DFS ioctl param type. 2395 * @value: Threshold value. 2396 */ 2397 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 2398 int dfs_set_thresholds(struct wlan_dfs *dfs, 2399 const uint32_t threshtype, 2400 const uint32_t value); 2401 #else 2402 static inline int dfs_set_thresholds(struct wlan_dfs *dfs, 2403 const uint32_t threshtype, 2404 const uint32_t value) 2405 { 2406 return 0; 2407 } 2408 #endif 2409 2410 /** 2411 * dfs_check_intersect_excl() - Check whether curfreq falls within lower_freq 2412 * and upper_freq, exclusively. 2413 * @low_freq : lower bound frequency value. 2414 * @high_freq: upper bound frequency value. 2415 * @chan_freq: Current frequency value to be checked. 2416 * 2417 * Return: returns true if overlap found, else returns false. 2418 */ 2419 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 2420 bool dfs_check_intersect_excl(int low_freq, int high_freq, int chan_freq); 2421 #else 2422 static inline bool dfs_check_intersect_excl(int low_freq, int high_freq, 2423 int chan_freq) 2424 { 2425 return false; 2426 } 2427 #endif 2428 2429 /** 2430 * dfs_check_etsi_overlap() - Check whether given frequency centre/channel 2431 * width entry overlap with frequency spread in any way. 2432 * @center_freq : current channel centre frequency. 2433 * @chan_width : current channel width. 2434 * @en302_502_freq_low : overlap frequency lower bound. 2435 * @en302_502_freq_high : overlap frequency upper bound. 2436 * 2437 * Return: returns 1 if overlap found, else returns 0. 2438 */ 2439 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 2440 int dfs_check_etsi_overlap(int center_freq, int chan_width, 2441 int en302_502_freq_low, int en302_502_freq_high); 2442 #else 2443 static inline int dfs_check_etsi_overlap(int center_freq, int chan_width, 2444 int en302_502_freq_low, 2445 int en302_502_freq_high) 2446 { 2447 return 0; 2448 } 2449 #endif 2450 2451 /** 2452 * dfs_is_en302_502_applicable() - Check whether current channel frequecy spread 2453 * overlaps with EN 302 502 radar type 2454 * frequency range. 2455 *@dfs: Pointer to wlan_dfs structure. 2456 * 2457 * Return: returns true if overlap found, else returns false. 2458 */ 2459 #if defined(WLAN_DFS_DIRECT_ATTACH) || defined(WLAN_DFS_PARTIAL_OFFLOAD) 2460 bool dfs_is_en302_502_applicable(struct wlan_dfs *dfs); 2461 #else 2462 static inline bool dfs_is_en302_502_applicable(struct wlan_dfs *dfs) 2463 { 2464 return false; 2465 } 2466 #endif 2467 2468 /** 2469 * dfs_set_current_channel() - Set DFS current channel. 2470 * @dfs: Pointer to wlan_dfs structure. 2471 * @dfs_ch_freq: Frequency in Mhz. 2472 * @dfs_ch_flags: Channel flags. 2473 * @dfs_ch_flagext: Extended channel flags. 2474 * @dfs_ch_ieee: IEEE channel number. 2475 * @dfs_ch_vhtop_ch_freq_seg1: Channel Center frequency1. 2476 * @dfs_ch_vhtop_ch_freq_seg2: Channel Center frequency2. 2477 */ 2478 #ifdef CONFIG_CHAN_NUM_API 2479 void dfs_set_current_channel(struct wlan_dfs *dfs, 2480 uint16_t dfs_ch_freq, 2481 uint64_t dfs_ch_flags, 2482 uint16_t dfs_ch_flagext, 2483 uint8_t dfs_ch_ieee, 2484 uint8_t dfs_ch_vhtop_ch_freq_seg1, 2485 uint8_t dfs_ch_vhtop_ch_freq_seg2); 2486 #endif 2487 2488 #ifdef CONFIG_CHAN_FREQ_API 2489 /** 2490 * dfs_set_current_channel_for_freq() - Set DFS current channel. 2491 * @dfs: Pointer to wlan_dfs structure. 2492 * @dfs_chan_freq: Frequency in Mhz. 2493 * @dfs_chan_flags: Channel flags. 2494 * @dfs_chan_flagext: Extended channel flags. 2495 * @dfs_chan_ieee: IEEE channel number. 2496 * @dfs_chan_vhtop_freq_seg1: Channel Center frequency1. 2497 * @dfs_chan_vhtop_freq_seg2: Channel Center frequency2. 2498 * @dfs_chan_mhz_freq_seg1: Channel center frequency of primary segment in MHZ. 2499 * @dfs_chan_mhz_freq_seg2: Channel center frequency of secondary segment in MHZ 2500 * applicable only for 80+80MHZ mode of operation. 2501 * @is_channel_updated: boolean to represent channel update. 2502 */ 2503 void dfs_set_current_channel_for_freq(struct wlan_dfs *dfs, 2504 uint16_t dfs_chan_freq, 2505 uint64_t dfs_chan_flags, 2506 uint16_t dfs_chan_flagext, 2507 uint8_t dfs_chan_ieee, 2508 uint8_t dfs_chan_vhtop_freq_seg1, 2509 uint8_t dfs_chan_vhtop_freq_seg2, 2510 uint16_t dfs_chan_mhz_freq_seg1, 2511 uint16_t dfs_chan_mhz_freq_seg2, 2512 bool *is_channel_updated); 2513 2514 #endif 2515 /** 2516 * dfs_get_nol_chfreq_and_chwidth() - Get channel freq and width from NOL list. 2517 * @dfs_nol: Pointer to NOL channel entry. 2518 * @nol_chfreq: Pointer to save channel frequency. 2519 * @nol_chwidth: Pointer to save channel width. 2520 * @index: Index to dfs_nol list. 2521 */ 2522 void dfs_get_nol_chfreq_and_chwidth(struct dfsreq_nolelem *dfs_nol, 2523 uint32_t *nol_chfreq, 2524 uint32_t *nol_chwidth, 2525 int index); 2526 2527 /** 2528 * dfs_process_phyerr_owl() - Process an Owl-style phy error. 2529 * @dfs: Pointer to wlan_dfs structure. 2530 * @buf: Phyerr buffer 2531 * @datalen: Phyerr buf len 2532 * @rssi: RSSI 2533 * @ext_rssi: Extension RSSI. 2534 * @rs_tstamp: Time stamp. 2535 * @fulltsf: TSF64. 2536 * @e: Pointer to dfs_phy_err structure. 2537 * 2538 * Return: Returns 1. 2539 */ 2540 int dfs_process_phyerr_owl(struct wlan_dfs *dfs, 2541 void *buf, 2542 uint16_t datalen, 2543 uint8_t rssi, 2544 uint8_t ext_rssi, 2545 uint32_t rs_tstamp, 2546 uint64_t fulltsf, 2547 struct dfs_phy_err *e); 2548 2549 /** 2550 * dfs_process_phyerr_sowl() -Process a Sowl/Howl style phy error. 2551 * @dfs: Pointer to wlan_dfs structure. 2552 * @buf: Phyerr buffer 2553 * @datalen: Phyerr buf len 2554 * @rssi: RSSI 2555 * @ext_rssi: Extension RSSI. 2556 * @rs_tstamp: Time stamp. 2557 * @fulltsf: TSF64. 2558 * @e: Pointer to dfs_phy_err structure. 2559 * 2560 * Return: Returns 1. 2561 */ 2562 int dfs_process_phyerr_sowl(struct wlan_dfs *dfs, 2563 void *buf, 2564 uint16_t datalen, 2565 uint8_t rssi, 2566 uint8_t ext_rssi, 2567 uint32_t rs_tstamp, 2568 uint64_t fulltsf, 2569 struct dfs_phy_err *e); 2570 2571 /** 2572 * dfs_process_phyerr_merlin() - Process a Merlin/Osprey style phy error. 2573 * dfs_phy_err struct. 2574 * @dfs: Pointer to wlan_dfs structure. 2575 * @buf: Phyerr buffer 2576 * @datalen: Phyerr buf len 2577 * @rssi: RSSI 2578 * @ext_rssi: Extension RSSI. 2579 * @rs_tstamp: Time stamp. 2580 * @fulltsf: TSF64. 2581 * @e: Pointer to dfs_phy_err structure. 2582 * 2583 * Return: Returns 1. 2584 */ 2585 int dfs_process_phyerr_merlin(struct wlan_dfs *dfs, 2586 void *buf, 2587 uint16_t datalen, 2588 uint8_t rssi, 2589 uint8_t ext_rssi, 2590 uint32_t rs_tstamp, 2591 uint64_t fulltsf, 2592 struct dfs_phy_err *e); 2593 2594 /* 2595 * __dfs_process_radarevent() - Continuation of process a radar event function. 2596 * @dfs: Pointer to wlan_dfs structure. 2597 * @ft: Pointer to dfs_filtertype structure. 2598 * @re: Pointer to dfs_event structure. 2599 * @this_ts: Timestamp. 2600 * 2601 * There is currently no way to specify that a radar event has occurred on 2602 * a specific channel, so the current methodology is to mark both the pri 2603 * and ext channels as being unavailable. This should be fixed for 802.11ac 2604 * or we'll quickly run out of valid channels to use. 2605 * 2606 * Return: If a radar event is found, return 1. Otherwise, return 0. 2607 */ 2608 void __dfs_process_radarevent(struct wlan_dfs *dfs, 2609 struct dfs_filtertype *ft, 2610 struct dfs_event *re, 2611 uint64_t this_ts, 2612 int *found, 2613 int *false_radar_found); 2614 2615 /** 2616 * dfs_radar_found_action() - Radar found action 2617 * @dfs: Pointer to wlan_dfs structure. 2618 * @bangradar: true if radar is due to bangradar command. 2619 * @seg_id: Segment id. 2620 */ 2621 void dfs_radar_found_action(struct wlan_dfs *dfs, 2622 bool bangradar, 2623 uint8_t seg_id); 2624 2625 /** 2626 * bin5_rules_check_internal() - This is a extension of dfs_bin5_check(). 2627 * @dfs: Pointer to wlan_dfs structure. 2628 * @br: Pointer to dfs_bin5radars structure. 2629 * @bursts: Bursts. 2630 * @numevents: Number of events. 2631 * @prev: prev index. 2632 * @i: Index. 2633 * @this: index to br_elems[] 2634 */ 2635 void bin5_rules_check_internal(struct wlan_dfs *dfs, 2636 struct dfs_bin5radars *br, 2637 uint32_t *bursts, 2638 uint32_t *numevents, 2639 uint32_t prev, 2640 uint32_t i, 2641 uint32_t this, 2642 int *index); 2643 2644 /** 2645 * dfs_main_task_testtimer_init() - Initialize dfs task testtimer. 2646 * @dfs: Pointer to wlan_dfs structure. 2647 */ 2648 void dfs_main_task_testtimer_init(struct wlan_dfs *dfs); 2649 2650 /** 2651 * dfs_stop() - Clear dfs timers. 2652 * @dfs: Pointer to wlan_dfs structure. 2653 */ 2654 void dfs_stop(struct wlan_dfs *dfs); 2655 2656 /** 2657 * dfs_update_cur_chan_flags() - Update DFS channel flag and flagext. 2658 * @dfs: Pointer to wlan_dfs structure. 2659 * @flags: New channel flags 2660 * @flagext: New Extended flags 2661 */ 2662 void dfs_update_cur_chan_flags(struct wlan_dfs *dfs, 2663 uint64_t flags, 2664 uint16_t flagext); 2665 2666 /** 2667 * dfs_radarevent_basic_sanity() - Check basic sanity of the radar event 2668 * @dfs: Pointer to wlan_dfs structure. 2669 * @chan: Current channel. 2670 * 2671 * Return: If a radar event found on NON-DFS channel return 0. Otherwise, 2672 * return 1. 2673 */ 2674 int dfs_radarevent_basic_sanity(struct wlan_dfs *dfs, 2675 struct dfs_channel *chan); 2676 2677 /** 2678 * wlan_psoc_get_dfs_txops() - Get dfs_tx_ops pointer 2679 * @psoc: Pointer to psoc structure. 2680 * 2681 * Return: Pointer to dfs_tx_ops. 2682 */ 2683 struct wlan_lmac_if_dfs_tx_ops * 2684 wlan_psoc_get_dfs_txops(struct wlan_objmgr_psoc *psoc); 2685 2686 /** 2687 * dfs_nol_free_list() - Free NOL elements. 2688 * @dfs: Pointer to wlan_dfs structure. 2689 */ 2690 void dfs_nol_free_list(struct wlan_dfs *dfs); 2691 2692 /** 2693 * dfs_second_segment_radar_disable() - Disables the second segment radar. 2694 * @dfs: Pointer to wlan_dfs structure. 2695 * 2696 * This is called when AP detects the radar, to (potentially) disable 2697 * the radar code. 2698 * 2699 * Return: returns 0. 2700 */ 2701 int dfs_second_segment_radar_disable(struct wlan_dfs *dfs); 2702 2703 /** 2704 * dfs_fetch_nol_ie_info() - Fill NOL information to be sent with RCSA. 2705 * @dfs - Pointer to wlan_dfs structure. 2706 * @nol_ie_bandwidth - Minimum subchannel bandwidth. 2707 * @nol_ie_startfreq - Radar affected channel list's first subchannel's 2708 * - centre frequency. 2709 * @nol_ie_bitmap - NOL bitmap denoting affected subchannels. 2710 */ 2711 void dfs_fetch_nol_ie_info(struct wlan_dfs *dfs, uint8_t *nol_ie_bandwidth, 2712 uint16_t *nol_ie_startfreq, uint8_t *nol_ie_bitmap); 2713 2714 /** 2715 * dfs_set_rcsa_flags() - Set flags that are required for sending RCSA and 2716 * NOL IE. 2717 * @dfs: Pointer to wlan_dfs structure. 2718 * @is_rcsa_ie_sent: Boolean to check if RCSA IE should be sent or not. 2719 * @is_nol_ie_sent: Boolean to check if NOL IE should be sent or not. 2720 */ 2721 void dfs_set_rcsa_flags(struct wlan_dfs *dfs, bool is_rcsa_ie_sent, 2722 bool is_nol_ie_sent); 2723 2724 /** 2725 * dfs_get_rcsa_flags() - Get flags that are required for sending RCSA and 2726 * NOL IE. 2727 * @dfs: Pointer to wlan_dfs structure. 2728 * @is_rcsa_ie_sent: Boolean to check if RCSA IE should be sent or not. 2729 * @is_nol_ie_sent: Boolean to check if NOL IE should be sent or not. 2730 */ 2731 void dfs_get_rcsa_flags(struct wlan_dfs *dfs, bool *is_rcsa_ie_sent, 2732 bool *is_nol_ie_sent); 2733 2734 /** 2735 * dfs_process_nol_ie_bitmap() - Update NOL with external radar information. 2736 * @dfs - Pointer to wlan_dfs structure. 2737 * @nol_ie_bandwidth - Minimum subchannel bandwidth. 2738 * @nol_ie_starfreq - Radar affected channel list's first subchannel's 2739 * - centre frequency. 2740 * @nol_ie_bitmap - Bitmap denoting radar affected subchannels. 2741 * 2742 * Return: True if NOL IE should be propagated, else false. 2743 */ 2744 bool dfs_process_nol_ie_bitmap(struct wlan_dfs *dfs, uint8_t nol_ie_bandwidth, 2745 uint16_t nol_ie_startfreq, 2746 uint8_t nol_ie_bitmap); 2747 2748 /** 2749 * dfs_is_cac_required() - Check if DFS CAC is required for the current channel. 2750 * @dfs: Pointer to wlan_dfs structure. 2751 * @cur_chan: Pointer to current channel of dfs_channel structure. 2752 * @prev_chan: Pointer to previous channel of dfs_channel structure. 2753 * @continue_current_cac: If AP can start CAC then this variable indicates 2754 * whether to continue with the current CAC or restart the CAC. This variable 2755 * is valid only if this function returns true. 2756 * 2757 * Return: true if AP requires CAC or can continue current CAC, else false. 2758 */ 2759 bool dfs_is_cac_required(struct wlan_dfs *dfs, 2760 struct dfs_channel *cur_chan, 2761 struct dfs_channel *prev_chan, 2762 bool *continue_current_cac); 2763 2764 /** 2765 * dfs_task_testtimer_reset() - stop dfs test timer. 2766 * @dfs: Pointer to wlan_dfs structure. 2767 */ 2768 void dfs_task_testtimer_reset(struct wlan_dfs *dfs); 2769 2770 /** 2771 * dfs_is_freq_in_nol() - check if given channel in nol list 2772 * @dfs: Pointer to wlan_dfs structure 2773 * @freq: channel frequency 2774 * 2775 * check if given channel in nol list. 2776 * 2777 * Return: true if channel in nol, false else 2778 */ 2779 bool dfs_is_freq_in_nol(struct wlan_dfs *dfs, uint32_t freq); 2780 2781 /** 2782 * dfs_task_testtimer_detach() - Free dfs test timer. 2783 * @dfs: Pointer to wlan_dfs structure. 2784 */ 2785 void dfs_task_testtimer_detach(struct wlan_dfs *dfs); 2786 2787 /** 2788 * dfs_timer_detach() - Free dfs timers. 2789 * @dfs: Pointer to wlan_dfs structure. 2790 */ 2791 void dfs_timer_detach(struct wlan_dfs *dfs); 2792 2793 /** 2794 * dfs_is_disable_radar_marking_set() - Check if radar marking is set on 2795 * NOL chan. 2796 * @dfs: Pointer to wlan_dfs structure. 2797 */ 2798 #if defined(WLAN_DFS_FULL_OFFLOAD) && defined(QCA_DFS_NOL_OFFLOAD) 2799 int dfs_is_disable_radar_marking_set(struct wlan_dfs *dfs, 2800 bool *disable_radar_marking); 2801 #else 2802 static inline int dfs_is_disable_radar_marking_set(struct wlan_dfs *dfs, 2803 bool *disable_radar_marking) 2804 { 2805 return QDF_STATUS_SUCCESS; 2806 } 2807 #endif 2808 /** 2809 * dfs_get_disable_radar_marking() - Get the value of disable radar marking. 2810 * @dfs: Pointer to wlan_dfs structure. 2811 */ 2812 #if defined(WLAN_DFS_FULL_OFFLOAD) && defined(QCA_DFS_NOL_OFFLOAD) 2813 bool dfs_get_disable_radar_marking(struct wlan_dfs *dfs); 2814 #endif 2815 2816 /** 2817 * dfs_reset_agile_config() - Reset the ADFS config variables. 2818 * @dfs: Pointer to dfs_soc_priv_obj. 2819 */ 2820 #ifdef QCA_SUPPORT_AGILE_DFS 2821 void dfs_reset_agile_config(struct dfs_soc_priv_obj *dfs_soc); 2822 #endif 2823 2824 /** 2825 * dfs_reinit_timers() - Reinit timers in DFS. 2826 * @dfs: Pointer to wlan_dfs. 2827 */ 2828 int dfs_reinit_timers(struct wlan_dfs *dfs); 2829 2830 /** 2831 * dfs_reset_dfs_prevchan() - Reset DFS previous channel structure. 2832 * @dfs: Pointer to wlan_dfs object. 2833 * 2834 * Return: None. 2835 */ 2836 void dfs_reset_dfs_prevchan(struct wlan_dfs *dfs); 2837 2838 /** 2839 * dfs_init_tmp_psoc_nol() - Init temporary psoc NOL structure. 2840 * @dfs: Pointer to wlan_dfs object. 2841 * @num_radios: Num of radios in the PSOC. 2842 * 2843 * Return: void. 2844 */ 2845 void dfs_init_tmp_psoc_nol(struct wlan_dfs *dfs, uint8_t num_radios); 2846 2847 /** 2848 * dfs_deinit_tmp_psoc_nol() - De-init temporary psoc NOL structure. 2849 * @dfs: Pointer to wlan_dfs object. 2850 * 2851 * Return: void. 2852 */ 2853 void dfs_deinit_tmp_psoc_nol(struct wlan_dfs *dfs); 2854 2855 /** 2856 * dfs_save_dfs_nol_in_psoc() - Save NOL data of given pdev. 2857 * @dfs: Pointer to wlan_dfs object. 2858 * @pdev_id: The pdev ID which will have the NOL data. 2859 * 2860 * Based on the frequency of the NOL channel, copy it to the target pdev_id 2861 * structure in psoc. 2862 * 2863 * Return: void. 2864 */ 2865 void dfs_save_dfs_nol_in_psoc(struct wlan_dfs *dfs, uint8_t pdev_id); 2866 2867 /** 2868 * dfs_reinit_nol_from_psoc_copy() - Reinit saved NOL data to corresponding 2869 * DFS object. 2870 * @dfs: Pointer to wlan_dfs object. 2871 * @pdev_id: pdev_id of the given dfs object. 2872 * @low_5ghz_freq: The low 5GHz frequency value of the target pdev id. 2873 * @high_5ghz_freq: The high 5GHz frequency value of the target pdev id. 2874 * 2875 * Return: void. 2876 */ 2877 void dfs_reinit_nol_from_psoc_copy(struct wlan_dfs *dfs, 2878 uint8_t pdev_id, 2879 uint16_t low_5ghz_freq, 2880 uint16_t high_5ghz_freq); 2881 2882 /** 2883 * dfs_is_hw_mode_switch_in_progress() - Check if HW mode switch in progress. 2884 * @dfs: Pointer to wlan_dfs object. 2885 * 2886 * Return: True if mode switch is in progress, else false. 2887 */ 2888 bool dfs_is_hw_mode_switch_in_progress(struct wlan_dfs *dfs); 2889 2890 /** 2891 * dfs_start_mode_switch_defer_timer() - start mode switch defer timer. 2892 * @dfs: Pointer to wlan_dfs object. 2893 * 2894 * Return: void. 2895 */ 2896 void dfs_start_mode_switch_defer_timer(struct wlan_dfs *dfs); 2897 2898 /** 2899 * dfs_complete_deferred_tasks() - Process mode switch completion event and 2900 * handle deffered tasks. 2901 * @dfs: Pointer to wlan_dfs object. 2902 * 2903 * Return: void. 2904 */ 2905 void dfs_complete_deferred_tasks(struct wlan_dfs *dfs); 2906 2907 /** 2908 * dfs_process_cac_completion() - Process DFS CAC completion event. 2909 * @dfs: Pointer to wlan_dfs object. 2910 * 2911 * Return: void. 2912 */ 2913 void dfs_process_cac_completion(struct wlan_dfs *dfs); 2914 2915 #ifdef WLAN_DFS_TRUE_160MHZ_SUPPORT 2916 /** 2917 * dfs_is_true_160mhz_supported() - Find if true 160MHz is supported. 2918 * @dfs: Pointer to wlan_dfs object. 2919 * 2920 * Return: True if true 160MHz is supported, else false. 2921 */ 2922 bool dfs_is_true_160mhz_supported(struct wlan_dfs *dfs); 2923 2924 /** 2925 * dfs_is_restricted_80p80mhz_supported() - Find if restricted 80p80mhz is 2926 * supported. 2927 * @dfs: Pointer to wlan_dfs object. 2928 * 2929 * Return: True if restricted 160MHz is supported, else false. 2930 */ 2931 bool dfs_is_restricted_80p80mhz_supported(struct wlan_dfs *dfs); 2932 #else 2933 static inline bool dfs_is_true_160mhz_supported(struct wlan_dfs *dfs) 2934 { 2935 return false; 2936 } 2937 2938 static inline bool dfs_is_restricted_80p80mhz_supported(struct wlan_dfs *dfs) 2939 { 2940 return false; 2941 } 2942 #endif /* WLAN_DFS_TRUE_160MHZ_SUPPORT */ 2943 2944 /** 2945 * dfs_get_agile_detector_id() - Find the Agile detector ID for given DFS. 2946 * @dfs: Pointer to wlan_dfs object. 2947 * 2948 * Return: Agile detector value (uint8_t). 2949 */ 2950 #ifdef QCA_SUPPORT_AGILE_DFS 2951 uint8_t dfs_get_agile_detector_id(struct wlan_dfs *dfs); 2952 #else 2953 static inline uint8_t dfs_get_agile_detector_id(struct wlan_dfs *dfs) 2954 { 2955 return INVALID_DETECTOR_ID; 2956 } 2957 #endif 2958 2959 /** 2960 * dfs_is_new_chan_subset_of_old_chan() - Find if new channel is subset of 2961 * old channel. 2962 * @dfs: Pointer to wlan_dfs structure. 2963 * @new_chan: Pointer to new channel of dfs_channel structure. 2964 * @old_chan: Pointer to old channel of dfs_channel structure. 2965 * 2966 * Return: True if new channel is subset of old channel, else false. 2967 */ 2968 bool dfs_is_new_chan_subset_of_old_chan(struct wlan_dfs *dfs, 2969 struct dfs_channel *new_chan, 2970 struct dfs_channel *old_chan); 2971 2972 /** 2973 * dfs_find_dfs_sub_channels_for_freq() - Given a dfs channel, find its 2974 * HT20 subset channels. 2975 * @dfs: Pointer to wlan_dfs structure. 2976 * @chan: Pointer to dfs_channel structure. 2977 * @subchan_arr: Pointer to subchannels array. 2978 * 2979 * Return: Number of sub channels. 2980 */ 2981 uint8_t dfs_find_dfs_sub_channels_for_freq(struct wlan_dfs *dfs, 2982 struct dfs_channel *chan, 2983 uint16_t *subchan_arr); 2984 2985 #endif /* _DFS_H_ */ 2986