93830f424d
Clean up null pointer asserts by returning the error status to the caller in the below spectral module files 1.spectral/core/spectral_common.c 2.target_if/spectral/target_if_spectral.h 3.target_if/spectral/target_if_spectral.c Change-Id: Ib8d49c06928379768fb41e34d721bd3840e86330 CRs-Fixed: 3587512
3100 wiersze
106 KiB
C
3100 wiersze
106 KiB
C
/*
|
|
* Copyright (c) 2011,2017-2021 The Linux Foundation. All rights reserved.
|
|
* Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for
|
|
* any purpose with or without fee is hereby granted, provided that the
|
|
* above copyright notice and this permission notice appear in all
|
|
* copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
|
|
* WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
|
|
* AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
|
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
|
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
|
|
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
* PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#ifndef _TARGET_IF_SPECTRAL_H_
|
|
#define _TARGET_IF_SPECTRAL_H_
|
|
|
|
#include <wlan_objmgr_cmn.h>
|
|
#include <wlan_objmgr_psoc_obj.h>
|
|
#include <wlan_objmgr_pdev_obj.h>
|
|
#include <wlan_objmgr_vdev_obj.h>
|
|
#include <wlan_reg_services_api.h>
|
|
#include <qdf_lock.h>
|
|
#include <wlan_spectral_public_structs.h>
|
|
#include <reg_services_public_struct.h>
|
|
#ifdef DIRECT_BUF_RX_ENABLE
|
|
#include <target_if_direct_buf_rx_api.h>
|
|
#endif
|
|
#ifdef WIN32
|
|
#pragma pack(push, target_if_spectral, 1)
|
|
#define __ATTRIB_PACK
|
|
#else
|
|
#ifndef __ATTRIB_PACK
|
|
#define __ATTRIB_PACK __attribute__ ((packed))
|
|
#endif
|
|
#endif
|
|
|
|
#include <spectral_defs_i.h>
|
|
#include <wmi_unified_param.h>
|
|
|
|
#define FREQ_OFFSET_10MHZ (10)
|
|
#define FREQ_OFFSET_40MHZ (40)
|
|
#define FREQ_OFFSET_80MHZ (80)
|
|
#define FREQ_OFFSET_85MHZ (85)
|
|
#ifndef SPECTRAL_USE_NL_BCAST
|
|
#define SPECTRAL_USE_NL_BCAST (0)
|
|
#endif
|
|
|
|
#define STATUS_PASS 1
|
|
#define STATUS_FAIL 0
|
|
#undef spectral_dbg_line
|
|
#define spectral_dbg_line() \
|
|
spectral_debug("----------------------------------------------------")
|
|
|
|
#undef spectral_ops_not_registered
|
|
#define spectral_ops_not_registered(str) \
|
|
spectral_info("SPECTRAL : %s not registered\n", (str))
|
|
#undef not_yet_implemented
|
|
#define not_yet_implemented() \
|
|
spectral_info("SPECTRAL : %s : %d Not yet implemented\n", \
|
|
__func__, __LINE__)
|
|
|
|
#define SPECTRAL_HT20_NUM_BINS 56
|
|
#define SPECTRAL_HT20_FFT_LEN 56
|
|
#define SPECTRAL_HT20_DC_INDEX (SPECTRAL_HT20_FFT_LEN / 2)
|
|
#define SPECTRAL_HT20_DATA_LEN 60
|
|
#define SPECTRAL_HT20_TOTAL_DATA_LEN (SPECTRAL_HT20_DATA_LEN + 3)
|
|
#define SPECTRAL_HT40_TOTAL_NUM_BINS 128
|
|
#define SPECTRAL_HT40_DATA_LEN 135
|
|
#define SPECTRAL_HT40_TOTAL_DATA_LEN (SPECTRAL_HT40_DATA_LEN + 3)
|
|
#define SPECTRAL_HT40_FFT_LEN 128
|
|
#define SPECTRAL_HT40_DC_INDEX (SPECTRAL_HT40_FFT_LEN / 2)
|
|
|
|
/*
|
|
* Used for the SWAR to obtain approximate combined rssi
|
|
* in secondary 80Mhz segment
|
|
*/
|
|
#define OFFSET_CH_WIDTH_20 65
|
|
#define OFFSET_CH_WIDTH_40 62
|
|
#define OFFSET_CH_WIDTH_80 56
|
|
#define OFFSET_CH_WIDTH_160 50
|
|
|
|
/* Min and max for relevant Spectral params */
|
|
#define SPECTRAL_PARAM_FFT_SIZE_MIN_GEN2 (1)
|
|
#define SPECTRAL_PARAM_FFT_SIZE_MAX_GEN2 (9)
|
|
#define SPECTRAL_PARAM_FFT_SIZE_MIN_GEN3 (5)
|
|
#define SPECTRAL_PARAM_FFT_SIZE_MAX_GEN3_DEFAULT (9)
|
|
#define SPECTRAL_PARAM_FFT_SIZE_MAX_GEN3_QCN9000 (10)
|
|
#define SPECTRAL_PARAM_FFT_SIZE_MIN_GEN3_BE (5)
|
|
#define SPECTRAL_PARAM_FFT_SIZE_MAX_GEN3_BE (11)
|
|
#define SPECTRAL_PARAM_FFT_SIZE_MAX_GEN3_BE_20MHZ (9)
|
|
#define SPECTRAL_PARAM_FFT_SIZE_MAX_GEN3_BE_40MHZ (10)
|
|
#define INVALID_FFT_SIZE (0xFFFF)
|
|
#define SPECTRAL_PARAM_RPT_MODE_MIN (0)
|
|
#define SPECTRAL_PARAM_RPT_MODE_MAX (3)
|
|
#define SPECTRAL_PARAM_SCAN_COUNT_MAX_GEN3 (4095)
|
|
#define SPECTRAL_PARAM_SCAN_COUNT_MAX_GEN3_BE (4095)
|
|
#define SPECTRAL_DWORD_SIZE (4)
|
|
|
|
#define MAX_FFTBIN_VALUE_LINEAR_MODE (U8_MAX)
|
|
#define MAX_FFTBIN_VALUE_DBM_MODE (S8_MAX)
|
|
#define MIN_FFTBIN_VALUE_DBM_MODE (S8_MIN)
|
|
#define MAX_FFTBIN_VALUE (255)
|
|
|
|
/* DBR ring debug size for Spectral */
|
|
#define SPECTRAL_DBR_RING_DEBUG_SIZE 512
|
|
|
|
#ifdef BIG_ENDIAN_HOST
|
|
#define SPECTRAL_MESSAGE_COPY_CHAR_ARRAY(destp, srcp, len) do { \
|
|
int j; \
|
|
uint32_t *src, *dest; \
|
|
src = (uint32_t *)(srcp); \
|
|
dest = (uint32_t *)(destp); \
|
|
for (j = 0; j < roundup((len), sizeof(uint32_t)) / 4; j++) { \
|
|
*(dest + j) = qdf_le32_to_cpu(*(src + j)); \
|
|
} \
|
|
} while (0)
|
|
#else
|
|
#define SPECTRAL_MESSAGE_COPY_CHAR_ARRAY(destp, srcp, len) \
|
|
OS_MEMCPY((destp), (srcp), (len));
|
|
#endif
|
|
|
|
#define DUMMY_NF_VALUE (-123)
|
|
/* 5 categories x (lower + upper) bands */
|
|
#define MAX_INTERF 10
|
|
#define HOST_MAX_ANTENNA 3
|
|
/* Mask for time stamp from descriptor */
|
|
#define SPECTRAL_TSMASK 0xFFFFFFFF
|
|
#define SPECTRAL_SIGNATURE 0xdeadbeef
|
|
/* Signature to write onto spectral buffer and then later validate */
|
|
#define MEM_POISON_SIGNATURE (htobe32(0xdeadbeef))
|
|
|
|
/* START of spectral GEN II HW specific details */
|
|
#define SPECTRAL_PHYERR_SIGNATURE_GEN2 0xbb
|
|
#define TLV_TAG_SPECTRAL_SUMMARY_REPORT_GEN2 0xF9
|
|
#define TLV_TAG_ADC_REPORT_GEN2 0xFA
|
|
#define TLV_TAG_SEARCH_FFT_REPORT_GEN2 0xFB
|
|
|
|
/*
|
|
* The Maximum number of detector information to be filled in the SAMP msg
|
|
* is 3, only for 165MHz case. For all other cases this value will be 1.
|
|
*/
|
|
#define MAX_NUM_DEST_DETECTOR_INFO (3)
|
|
#define MAX_DETECTORS_PER_PDEV (3)
|
|
#define FFT_BIN_SIZE_1BYTE (1)
|
|
|
|
#ifdef OPTIMIZED_SAMP_MESSAGE
|
|
/**
|
|
* enum spectral_160mhz_report_delivery_state - 160 MHz state machine states
|
|
* @SPECTRAL_REPORT_WAIT_PRIMARY80: Wait for primary80 report
|
|
* @SPECTRAL_REPORT_WAIT_SECONDARY80: Wait for secondory 80 report
|
|
*/
|
|
enum spectral_160mhz_report_delivery_state {
|
|
SPECTRAL_REPORT_WAIT_PRIMARY80,
|
|
SPECTRAL_REPORT_WAIT_SECONDARY80,
|
|
};
|
|
#else
|
|
/**
|
|
* enum spectral_160mhz_report_delivery_state - 160 MHz state machine states
|
|
* @SPECTRAL_REPORT_WAIT_PRIMARY80: Wait for primary80 report
|
|
* @SPECTRAL_REPORT_RX_PRIMARY80: Receive primary 80 report
|
|
* @SPECTRAL_REPORT_WAIT_SECONDARY80: Wait for secondory 80 report
|
|
* @SPECTRAL_REPORT_RX_SECONDARY80: Receive secondary 80 report
|
|
*/
|
|
enum spectral_160mhz_report_delivery_state {
|
|
SPECTRAL_REPORT_WAIT_PRIMARY80,
|
|
SPECTRAL_REPORT_RX_PRIMARY80,
|
|
SPECTRAL_REPORT_WAIT_SECONDARY80,
|
|
SPECTRAL_REPORT_RX_SECONDARY80,
|
|
};
|
|
#endif /* OPTIMIZED_SAMP_MESSAGE */
|
|
|
|
/**
|
|
* enum spectral_freq_span_id - Spectral frequency span id
|
|
* @SPECTRAL_FREQ_SPAN_ID_0: Frequency span 0
|
|
* @SPECTRAL_FREQ_SPAN_ID_1: Frequency span 1
|
|
* @SPECTRAL_FREQ_SPAN_ID_2: Frequency span 2
|
|
*/
|
|
enum spectral_freq_span_id {
|
|
SPECTRAL_FREQ_SPAN_ID_0,
|
|
SPECTRAL_FREQ_SPAN_ID_1,
|
|
SPECTRAL_FREQ_SPAN_ID_2,
|
|
};
|
|
|
|
/**
|
|
* enum spectral_detector_id - Spectral detector id
|
|
* @SPECTRAL_DETECTOR_ID_0: Spectral detector 0
|
|
* @SPECTRAL_DETECTOR_ID_1: Spectral detector 1
|
|
* @SPECTRAL_DETECTOR_ID_2: Spectral detector 2
|
|
* @SPECTRAL_DETECTOR_ID_MAX: Max Spectral detector ID
|
|
* @SPECTRAL_DETECTOR_ID_INVALID: Invalid Spectral detector ID
|
|
*/
|
|
enum spectral_detector_id {
|
|
SPECTRAL_DETECTOR_ID_0,
|
|
SPECTRAL_DETECTOR_ID_1,
|
|
SPECTRAL_DETECTOR_ID_2,
|
|
SPECTRAL_DETECTOR_ID_MAX,
|
|
SPECTRAL_DETECTOR_ID_INVALID = 0xff,
|
|
};
|
|
|
|
/**
|
|
* struct spectral_search_fft_info_gen2 - spectral search fft report for gen2
|
|
* @relpwr_db: Total bin power in db
|
|
* @num_str_bins_ib: Number of strong bins
|
|
* @base_pwr: Base power
|
|
* @total_gain_info: Total gain
|
|
* @fft_chn_idx: FFT chain on which report is originated
|
|
* @avgpwr_db: Average power in db
|
|
* @peak_mag: Peak power seen in the bins
|
|
* @peak_inx: Index of bin holding peak power
|
|
*/
|
|
struct spectral_search_fft_info_gen2 {
|
|
uint32_t relpwr_db;
|
|
uint32_t num_str_bins_ib;
|
|
uint32_t base_pwr;
|
|
uint32_t total_gain_info;
|
|
uint32_t fft_chn_idx;
|
|
uint32_t avgpwr_db;
|
|
uint32_t peak_mag;
|
|
int16_t peak_inx;
|
|
};
|
|
|
|
/*
|
|
* XXX Check if we should be handling the endinness difference in some
|
|
* other way opaque to the host
|
|
*/
|
|
#ifdef BIG_ENDIAN_HOST
|
|
|
|
/**
|
|
* struct spectral_phyerr_tlv_gen2 - phyerr tlv info for big endian host
|
|
* @signature: signature
|
|
* @tag: tag
|
|
* @length: length
|
|
*/
|
|
struct spectral_phyerr_tlv_gen2 {
|
|
uint8_t signature;
|
|
uint8_t tag;
|
|
uint16_t length;
|
|
} __ATTRIB_PACK;
|
|
|
|
#else
|
|
|
|
/**
|
|
* struct spectral_phyerr_tlv_gen2 - phyerr tlv info for little endian host
|
|
* @length: length
|
|
* @tag: tag
|
|
* @signature: signature
|
|
*/
|
|
struct spectral_phyerr_tlv_gen2 {
|
|
uint16_t length;
|
|
uint8_t tag;
|
|
uint8_t signature;
|
|
} __ATTRIB_PACK;
|
|
|
|
#endif /* BIG_ENDIAN_HOST */
|
|
|
|
/**
|
|
* struct spectral_phyerr_hdr_gen2 - phyerr header for gen2 HW
|
|
* @hdr_a: Header[0:31]
|
|
* @hdr_b: Header[32:63]
|
|
*/
|
|
struct spectral_phyerr_hdr_gen2 {
|
|
uint32_t hdr_a;
|
|
uint32_t hdr_b;
|
|
};
|
|
|
|
/*
|
|
* Segment ID information for 80+80.
|
|
*
|
|
* If the HW micro-architecture specification extends this DWORD for other
|
|
* purposes, then redefine+rename accordingly. For now, the specification
|
|
* mentions only segment ID (though this doesn't require an entire DWORD)
|
|
* without mention of any generic terminology for the DWORD, or any reservation.
|
|
* We use nomenclature accordingly.
|
|
*/
|
|
typedef uint32_t SPECTRAL_SEGID_INFO;
|
|
|
|
/**
|
|
* struct spectral_phyerr_fft_gen2 - fft info in phyerr event
|
|
* @buf: fft report
|
|
*/
|
|
struct spectral_phyerr_fft_gen2 {
|
|
uint8_t buf[0];
|
|
};
|
|
|
|
/**
|
|
* struct spectral_process_phyerr_info_gen2 - Processed phyerr info structures
|
|
* needed to fill SAMP params for gen2
|
|
* @p_rfqual: Pointer to RF quality info
|
|
* @p_sfft: Pointer to Search fft report info
|
|
* @pfft: Pointer to FFT info in Phyerr event
|
|
* @acs_stats: Pointer to ACS stats struct
|
|
* @tsf64: 64 bit TSF value
|
|
* @seg_id: Segment ID
|
|
*/
|
|
struct spectral_process_phyerr_info_gen2 {
|
|
struct target_if_spectral_rfqual_info *p_rfqual;
|
|
struct spectral_search_fft_info_gen2 *p_sfft;
|
|
struct spectral_phyerr_fft_gen2 *pfft;
|
|
struct target_if_spectral_acs_stats *acs_stats;
|
|
uint64_t tsf64;
|
|
uint8_t seg_id;
|
|
};
|
|
|
|
/* END of spectral GEN II HW specific details */
|
|
|
|
/* START of spectral GEN III HW specific details */
|
|
|
|
#define get_bitfield(value, size, pos) \
|
|
(((value) >> (pos)) & ((1 << (size)) - 1))
|
|
#define unsigned_to_signed(value, width) \
|
|
(((value) >= (1 << ((width) - 1))) ? \
|
|
(value - (1 << (width))) : (value))
|
|
|
|
#define SSCAN_SUMMARY_REPORT_HDR_A_DETECTOR_ID_POS_GEN3 (29)
|
|
#define SSCAN_SUMMARY_REPORT_HDR_A_DETECTOR_ID_SIZE_GEN3 (2)
|
|
#define SSCAN_SUMMARY_REPORT_HDR_A_AGC_TOTAL_GAIN_POS_GEN3 (0)
|
|
#define SSCAN_SUMMARY_REPORT_HDR_A_AGC_TOTAL_GAIN_SIZE_GEN3 (8)
|
|
#define SSCAN_SUMMARY_REPORT_HDR_A_INBAND_PWR_DB_POS_GEN3 (18)
|
|
#define SSCAN_SUMMARY_REPORT_HDR_A_INBAND_PWR_DB_SIZE_GEN3 (10)
|
|
#define SSCAN_SUMMARY_REPORT_HDR_A_PRI80_POS_GEN3 (31)
|
|
#define SSCAN_SUMMARY_REPORT_HDR_A_PRI80_SIZE_GEN3 (1)
|
|
#define SSCAN_SUMMARY_REPORT_HDR_B_GAINCHANGE_POS_GEN3_V1 (30)
|
|
#define SSCAN_SUMMARY_REPORT_HDR_B_GAINCHANGE_SIZE_GEN3_V1 (1)
|
|
#define SSCAN_SUMMARY_REPORT_HDR_C_GAINCHANGE_POS_GEN3_V2 (16)
|
|
#define SSCAN_SUMMARY_REPORT_HDR_C_GAINCHANGE_SIZE_GEN3_V2 (1)
|
|
#define SSCAN_SUMMARY_REPORT_PAD_HDR_A_BLANKING_POS_GEN3_V2 (0)
|
|
#define SSCAN_SUMMARY_REPORT_PAD_HDR_A_BLANKING_SIZE_GEN3_V2 (32)
|
|
#define SSCAN_SUMMARY_REPORT_PAD_HDR_A_BLANKING_TAG_GEN3_V2 (0xc0debeaf)
|
|
#define SPECTRAL_REPORT_LTS_HDR_LENGTH_POS_GEN3 (0)
|
|
#define SPECTRAL_REPORT_LTS_HDR_LENGTH_SIZE_GEN3 (16)
|
|
#define SPECTRAL_REPORT_LTS_TAG_POS_GEN3 (16)
|
|
#define SPECTRAL_REPORT_LTS_TAG_SIZE_GEN3 (8)
|
|
#define SPECTRAL_REPORT_LTS_SIGNATURE_POS_GEN3 (24)
|
|
#define SPECTRAL_REPORT_LTS_SIGNATURE_SIZE_GEN3 (8)
|
|
#define FFT_REPORT_HDR_A_DETECTOR_ID_POS_GEN3 (0)
|
|
#define FFT_REPORT_HDR_A_DETECTOR_ID_SIZE_GEN3 (2)
|
|
#define FFT_REPORT_HDR_A_FFT_NUM_POS_GEN3 (2)
|
|
#define FFT_REPORT_HDR_A_FFT_NUM_SIZE_GEN3 (3)
|
|
#define FFT_REPORT_HDR_A_RADAR_CHECK_POS_GEN3_V1 (5)
|
|
#define FFT_REPORT_HDR_A_RADAR_CHECK_SIZE_GEN3_V1 (12)
|
|
#define FFT_REPORT_HDR_A_RADAR_CHECK_POS_GEN3_V2 (5)
|
|
#define FFT_REPORT_HDR_A_RADAR_CHECK_SIZE_GEN3_V2 (14)
|
|
#define FFT_REPORT_HDR_A_PEAK_INDEX_POS_GEN3_V1 (17)
|
|
#define FFT_REPORT_HDR_A_PEAK_INDEX_SIZE_GEN3_V1 (11)
|
|
#define FFT_REPORT_HDR_A_PEAK_INDEX_POS_GEN3_V2 (19)
|
|
#define FFT_REPORT_HDR_A_PEAK_INDEX_SIZE_GEN3_V2 (11)
|
|
#define FFT_REPORT_HDR_A_CHAIN_INDEX_POS_GEN3_V1 (28)
|
|
#define FFT_REPORT_HDR_A_CHAIN_INDEX_SIZE_GEN3_V1 (3)
|
|
#define FFT_REPORT_HDR_B_CHAIN_INDEX_POS_GEN3_V2 (0)
|
|
#define FFT_REPORT_HDR_B_CHAIN_INDEX_SIZE_GEN3_V2 (3)
|
|
#define FFT_REPORT_HDR_B_BASE_PWR_POS_GEN3_V1 (0)
|
|
#define FFT_REPORT_HDR_B_BASE_PWR_SIZE_GEN3_V1 (9)
|
|
#define FFT_REPORT_HDR_B_BASE_PWR_POS_GEN3_V2 (3)
|
|
#define FFT_REPORT_HDR_B_BASE_PWR_SIZE_GEN3_V2 (9)
|
|
#define FFT_REPORT_HDR_B_TOTAL_GAIN_POS_GEN3_V1 (9)
|
|
#define FFT_REPORT_HDR_B_TOTAL_GAIN_SIZE_GEN3_V1 (8)
|
|
#define FFT_REPORT_HDR_B_TOTAL_GAIN_POS_GEN3_V2 (12)
|
|
#define FFT_REPORT_HDR_B_TOTAL_GAIN_SIZE_GEN3_V2 (8)
|
|
#define FFT_REPORT_HDR_C_NUM_STRONG_BINS_POS_GEN3 (0)
|
|
#define FFT_REPORT_HDR_C_NUM_STRONG_BINS_SIZE_GEN3 (8)
|
|
#define FFT_REPORT_HDR_C_PEAK_MAGNITUDE_POS_GEN3 (8)
|
|
#define FFT_REPORT_HDR_C_PEAK_MAGNITUDE_SIZE_GEN3 (10)
|
|
#define FFT_REPORT_HDR_C_AVG_PWR_POS_GEN3 (18)
|
|
#define FFT_REPORT_HDR_C_AVG_PWR_SIZE_GEN3 (7)
|
|
#define FFT_REPORT_HDR_C_RELATIVE_PWR_POS_GEN3 (25)
|
|
#define FFT_REPORT_HDR_C_RELATIVE_PWR_SIZE_GEN3 (7)
|
|
|
|
#define SPECTRAL_PHYERR_SIGNATURE_GEN3 (0xFA)
|
|
#define TLV_TAG_SPECTRAL_SUMMARY_REPORT_GEN3 (0x02)
|
|
#define TLV_TAG_SEARCH_FFT_REPORT_GEN3 (0x03)
|
|
#define SPECTRAL_PHYERR_TLVSIZE_GEN3 (4)
|
|
|
|
#define NUM_SPECTRAL_DETECTORS_GEN3_V1 (3)
|
|
#define NUM_SPECTRAL_DETECTORS_GEN3_V2 (2)
|
|
#define FFT_REPORT_HEADER_LENGTH_GEN3_V2 (24)
|
|
#define FFT_REPORT_HEADER_LENGTH_GEN3_V1 (16)
|
|
#define NUM_PADDING_BYTES_SSCAN_SUMARY_REPORT_GEN3_V1 (0)
|
|
#define NUM_PADDING_BYTES_SSCAN_SUMARY_REPORT_GEN3_V2 (16)
|
|
|
|
#define SPECTRAL_PHYERR_HDR_LTS_POS \
|
|
(offsetof(struct spectral_phyerr_fft_report_gen3, fft_hdr_lts))
|
|
#define SPECTRAL_FFT_BINS_POS \
|
|
(offsetof(struct spectral_phyerr_fft_report_gen3, buf))
|
|
|
|
/**
|
|
* struct phyerr_info - spectral search fft report for gen3
|
|
* @data: handle to phyerror buffer
|
|
* @datalen: length of phyerror buffer
|
|
* @p_rfqual: rf quality matrices
|
|
* @p_chaninfo: pointer to chaninfo
|
|
* @tsf64: 64 bit TSF
|
|
* @acs_stats: acs stats
|
|
*/
|
|
struct phyerr_info {
|
|
uint8_t *data;
|
|
uint32_t datalen;
|
|
struct target_if_spectral_rfqual_info *p_rfqual;
|
|
struct target_if_spectral_chan_info *p_chaninfo;
|
|
uint64_t tsf64;
|
|
struct target_if_spectral_acs_stats *acs_stats;
|
|
};
|
|
|
|
/**
|
|
* struct spectral_search_fft_info_gen3 - spectral search fft report for gen3
|
|
* @timestamp: Timestamp at which fft report was generated
|
|
* @last_raw_timestamp: Previous FFT report's raw timestamp
|
|
* @adjusted_timestamp: Adjusted timestamp to account for target reset
|
|
* @fft_detector_id: Which radio generated this report
|
|
* @fft_num: The FFT count number. Set to 0 for short FFT.
|
|
* @fft_radar_check: NA for spectral
|
|
* @fft_peak_sidx: Index of bin with maximum power
|
|
* @fft_chn_idx: Rx chain index
|
|
* @fft_base_pwr_db: Base power in dB
|
|
* @fft_total_gain_db: Total gain in dB
|
|
* @fft_num_str_bins_ib: Number of strong bins in the report
|
|
* @fft_peak_mag: Peak magnitude
|
|
* @fft_avgpwr_db: Average power in dB
|
|
* @fft_relpwr_db: Relative power in dB
|
|
* @fft_bin_count: Number of FFT bins in the FFT report
|
|
* @fft_bin_size: Size of one FFT bin in bytes
|
|
* @bin_pwr_data: Contains FFT bins extracted from the report
|
|
*/
|
|
struct spectral_search_fft_info_gen3 {
|
|
uint32_t timestamp;
|
|
uint32_t last_raw_timestamp;
|
|
uint32_t adjusted_timestamp;
|
|
uint32_t fft_detector_id;
|
|
uint32_t fft_num;
|
|
uint32_t fft_radar_check;
|
|
int32_t fft_peak_sidx;
|
|
uint32_t fft_chn_idx;
|
|
uint32_t fft_base_pwr_db;
|
|
uint32_t fft_total_gain_db;
|
|
uint32_t fft_num_str_bins_ib;
|
|
int32_t fft_peak_mag;
|
|
uint32_t fft_avgpwr_db;
|
|
uint32_t fft_relpwr_db;
|
|
uint32_t fft_bin_count;
|
|
uint8_t fft_bin_size;
|
|
uint8_t *bin_pwr_data;
|
|
};
|
|
|
|
/**
|
|
* struct spectral_phyerr_fft_report_gen3 - fft info in phyerr event
|
|
* @fft_timestamp: Timestamp at which fft report was generated
|
|
* @fft_hdr_lts: length, tag, signature fields
|
|
* @hdr_a: Header[0:31]
|
|
* @hdr_b: Header[32:63]
|
|
* @hdr_c: Header[64:95]
|
|
* @resv: Header[96:127]
|
|
* @buf: fft bins
|
|
*/
|
|
struct spectral_phyerr_fft_report_gen3 {
|
|
uint32_t fft_timestamp;
|
|
uint32_t fft_hdr_lts;
|
|
uint32_t hdr_a;
|
|
uint32_t hdr_b;
|
|
uint32_t hdr_c;
|
|
uint32_t resv;
|
|
uint8_t buf[0];
|
|
} __ATTRIB_PACK;
|
|
|
|
/**
|
|
* struct sscan_report_fields_gen3 - Fields of spectral report
|
|
* @sscan_agc_total_gain: The AGC total gain in DB.
|
|
* @inband_pwr_db: The in-band power of the signal in 1/2 DB steps
|
|
* @sscan_gainchange: This bit is set to 1 if a gainchange occurred during
|
|
* the spectral scan FFT. Software may choose to
|
|
* disregard the results.
|
|
* @sscan_pri80: This is set to 1 to indicate that the Spectral scan was
|
|
* performed on the pri80 segment. Software may choose to
|
|
* disregard the FFT sample if this is set to 1 but detector ID
|
|
* does not correspond to the ID for the pri80 segment.
|
|
* @sscan_detector_id: Detector ID in Spectral scan report
|
|
* @blanking_status: Indicates whether scan blanking was enabled during this
|
|
* spectral report capture. This field is applicable only when scan blanking
|
|
* feature is enabled. When scan blanking feature is disabled, this field
|
|
* will be set to zero.
|
|
*/
|
|
struct sscan_report_fields_gen3 {
|
|
uint8_t sscan_agc_total_gain;
|
|
int16_t inband_pwr_db;
|
|
uint8_t sscan_gainchange;
|
|
uint8_t sscan_pri80;
|
|
uint8_t sscan_detector_id;
|
|
uint8_t blanking_status;
|
|
};
|
|
|
|
/**
|
|
* struct spectral_sscan_summary_report_gen3 - Spectral summary report
|
|
* event
|
|
* @sscan_timestamp: Timestamp at which fft report was generated
|
|
* @sscan_hdr_lts: length, tag, signature fields
|
|
* @hdr_a: Header[0:31]
|
|
* @res1: Header[32:63]
|
|
* @hdr_b: Header[64:95]
|
|
* @hdr_c: Header[96:127]
|
|
*/
|
|
struct spectral_sscan_summary_report_gen3 {
|
|
u_int32_t sscan_timestamp;
|
|
u_int32_t sscan_hdr_lts;
|
|
u_int32_t hdr_a;
|
|
u_int32_t res1;
|
|
u_int32_t hdr_b;
|
|
u_int32_t hdr_c;
|
|
} __ATTRIB_PACK;
|
|
|
|
/**
|
|
* struct spectral_sscan_summary_report_padding_gen3_v2 - Spectral summary
|
|
* report padding region
|
|
* @hdr_a: Header[0:31]
|
|
* @hdr_b: Header[32:63]
|
|
* @hdr_c: Header[64:95]
|
|
* @hdr_d: Header[96:127]
|
|
*/
|
|
struct spectral_sscan_summary_report_padding_gen3_v2 {
|
|
u_int32_t hdr_a;
|
|
u_int32_t hdr_b;
|
|
u_int32_t hdr_c;
|
|
u_int32_t hdr_d;
|
|
} __ATTRIB_PACK;
|
|
|
|
#ifdef DIRECT_BUF_RX_ENABLE
|
|
/**
|
|
* struct spectral_report - spectral report
|
|
* @data: Report buffer
|
|
* @noisefloor: Noise floor values
|
|
* @reset_delay: Time taken for warm reset in us
|
|
* @cfreq1: center frequency 1
|
|
* @cfreq2: center frequency 2
|
|
* @ch_width: channel width
|
|
*/
|
|
struct spectral_report {
|
|
uint8_t *data;
|
|
int32_t noisefloor[DBR_MAX_CHAINS];
|
|
uint32_t reset_delay;
|
|
uint32_t cfreq1;
|
|
uint32_t cfreq2;
|
|
uint32_t ch_width;
|
|
};
|
|
#endif
|
|
/* END of spectral GEN III HW specific details */
|
|
|
|
typedef signed char pwr_dbm;
|
|
|
|
/**
|
|
* enum spectral_gen - spectral hw generation
|
|
* @SPECTRAL_GEN1 : spectral hw gen 1
|
|
* @SPECTRAL_GEN2 : spectral hw gen 2
|
|
* @SPECTRAL_GEN3 : spectral hw gen 3
|
|
*/
|
|
enum spectral_gen {
|
|
SPECTRAL_GEN1,
|
|
SPECTRAL_GEN2,
|
|
SPECTRAL_GEN3,
|
|
};
|
|
|
|
/**
|
|
* enum spectral_fftbin_size_war - spectral fft bin size war
|
|
* @SPECTRAL_FFTBIN_SIZE_NO_WAR: No WAR applicable for Spectral FFT bin size
|
|
* @SPECTRAL_FFTBIN_SIZE_WAR_2BYTE_TO_1BYTE: Spectral FFT bin size: Retain only
|
|
* least significant byte from 2 byte
|
|
* FFT bin transferred by HW
|
|
* @SPECTRAL_FFTBIN_SIZE_WAR_4BYTE_TO_1BYTE: Spectral FFT bin size: Retain only
|
|
* least significant byte from 4 byte
|
|
* FFT bin transferred by HW
|
|
*/
|
|
enum spectral_fftbin_size_war {
|
|
SPECTRAL_FFTBIN_SIZE_NO_WAR = 0,
|
|
SPECTRAL_FFTBIN_SIZE_WAR_2BYTE_TO_1BYTE = 1,
|
|
SPECTRAL_FFTBIN_SIZE_WAR_4BYTE_TO_1BYTE = 2,
|
|
};
|
|
|
|
/**
|
|
* enum spectral_report_format_version - This represents the report format
|
|
* version number within each Spectral generation.
|
|
* @SPECTRAL_REPORT_FORMAT_VERSION_1 : version 1
|
|
* @SPECTRAL_REPORT_FORMAT_VERSION_2 : version 2
|
|
*/
|
|
enum spectral_report_format_version {
|
|
SPECTRAL_REPORT_FORMAT_VERSION_1,
|
|
SPECTRAL_REPORT_FORMAT_VERSION_2,
|
|
};
|
|
|
|
/**
|
|
* struct spectral_fft_bin_len_adj_swar - Encapsulate information required for
|
|
* Spectral FFT bin length adjusting software WARS.
|
|
* @inband_fftbin_size_adj: Whether to carry out FFT bin size adjustment for
|
|
* in-band report format. This would be required on some chipsets under the
|
|
* following circumstances: In report mode 2 only the in-band bins are DMA'ed.
|
|
* Scatter/gather is used. However, the HW generates all bins, not just in-band,
|
|
* and reports the number of bins accordingly. The subsystem arranging for the
|
|
* DMA cannot change this value. On such chipsets the adjustment required at the
|
|
* host driver is to check if report format is 2, and if so halve the number of
|
|
* bins reported to get the number actually DMA'ed.
|
|
* @null_fftbin_adj: Whether to remove NULL FFT bins for report mode (1) in
|
|
* which only summary of metrics for each completed FFT + spectral scan summary
|
|
* report are to be provided. This would be required on some chipsets under the
|
|
* following circumstances: In report mode 1, HW reports a length corresponding
|
|
* to all bins, and provides bins with value 0. This is because the subsystem
|
|
* arranging for the FFT information does not arrange for DMA of FFT bin values
|
|
* (as expected), but cannot arrange for a smaller length to be reported by HW.
|
|
* In these circumstances, the driver would have to disregard the NULL bins and
|
|
* report a bin count of 0 to higher layers.
|
|
* @packmode_fftbin_size_adj: Pack mode in HW refers to packing of each Spectral
|
|
* FFT bin into 2 bytes. But due to a bug HW reports 2 times the expected length
|
|
* when packmode is enabled. This SWAR compensates this bug by dividing the
|
|
* length with 2.
|
|
* @fftbin_size_war: Type of FFT bin size SWAR
|
|
*/
|
|
struct spectral_fft_bin_len_adj_swar {
|
|
u_int8_t inband_fftbin_size_adj;
|
|
u_int8_t null_fftbin_adj;
|
|
uint8_t packmode_fftbin_size_adj;
|
|
enum spectral_fftbin_size_war fftbin_size_war;
|
|
};
|
|
|
|
/**
|
|
* struct spectral_report_params - Parameters related to format of Spectral
|
|
* report.
|
|
* @version: This represents the report format version number within each
|
|
* Spectral generation.
|
|
* @ssummary_padding_bytes: Number of bytes of padding after Spectral summary
|
|
* report
|
|
* @fft_report_hdr_len: Number of bytes in the header of the FFT report. This
|
|
* has to be subtracted from the length field of FFT report to find the length
|
|
* of FFT bins.
|
|
* @fragmentation_160: This indicates whether Spectral reports in 160/80p80 is
|
|
* fragmented.
|
|
* @detid_mode_table: Detector ID to Spectral scan mode table
|
|
* @num_spectral_detectors: Total number of Spectral detectors
|
|
* @marker: Describes the boundaries of pri80, 5 MHz and sec80 bins
|
|
* @hw_fft_bin_width: FFT bin width reported by the HW
|
|
*/
|
|
struct spectral_report_params {
|
|
enum spectral_report_format_version version;
|
|
uint8_t ssummary_padding_bytes;
|
|
uint8_t fft_report_hdr_len;
|
|
bool fragmentation_160[SPECTRAL_SCAN_MODE_MAX];
|
|
enum spectral_scan_mode detid_mode_table[SPECTRAL_DETECTOR_ID_MAX];
|
|
uint8_t num_spectral_detectors;
|
|
struct spectral_fft_bin_markers_160_165mhz
|
|
marker[SPECTRAL_SCAN_MODE_MAX];
|
|
uint8_t hw_fft_bin_width;
|
|
};
|
|
|
|
/**
|
|
* struct spectral_param_min_max - Spectral parameter minimum and maximum values
|
|
* @fft_size_min: Minimum value of fft_size
|
|
* @fft_size_max: Maximum value of fft_size for each BW
|
|
* @scan_count_max: Maximum value of scan count
|
|
*/
|
|
struct spectral_param_min_max {
|
|
uint16_t fft_size_min;
|
|
uint16_t fft_size_max[CH_WIDTH_MAX];
|
|
uint16_t scan_count_max;
|
|
};
|
|
|
|
/**
|
|
* struct spectral_timestamp_war - Spectral time stamp WAR related parameters
|
|
* @timestamp_war_offset: Offset to be added to correct timestamp
|
|
* @target_reset_count: Number of times target exercised the reset routine
|
|
* @last_fft_timestamp: last fft report timestamp
|
|
*/
|
|
struct spectral_timestamp_war {
|
|
uint32_t timestamp_war_offset[SPECTRAL_SCAN_MODE_MAX];
|
|
uint64_t target_reset_count;
|
|
uint32_t last_fft_timestamp[SPECTRAL_SCAN_MODE_MAX];
|
|
};
|
|
|
|
#if ATH_PERF_PWR_OFFLOAD
|
|
/**
|
|
* enum target_if_spectral_info - Enumerations for specifying which spectral
|
|
* information (among parameters and states)
|
|
* is desired.
|
|
* @TARGET_IF_SPECTRAL_INFO_ACTIVE: Indicated whether spectral is active
|
|
* @TARGET_IF_SPECTRAL_INFO_ENABLED: Indicated whether spectral is enabled
|
|
* @TARGET_IF_SPECTRAL_INFO_PARAMS: Config params
|
|
*/
|
|
enum target_if_spectral_info {
|
|
TARGET_IF_SPECTRAL_INFO_ACTIVE,
|
|
TARGET_IF_SPECTRAL_INFO_ENABLED,
|
|
TARGET_IF_SPECTRAL_INFO_PARAMS,
|
|
};
|
|
#endif /* ATH_PERF_PWR_OFFLOAD */
|
|
|
|
/* forward declaration */
|
|
struct target_if_spectral;
|
|
|
|
/**
|
|
* struct target_if_spectral_chan_info - Channel information
|
|
* @center_freq1: center frequency 1 in MHz
|
|
* @center_freq2: center frequency 2 in MHz -valid only for
|
|
* 11ACVHT 80PLUS80 mode
|
|
* @chan_width: channel width in MHz
|
|
*/
|
|
struct target_if_spectral_chan_info {
|
|
uint16_t center_freq1;
|
|
uint16_t center_freq2;
|
|
uint8_t chan_width;
|
|
};
|
|
|
|
/**
|
|
* struct target_if_spectral_acs_stats - EACS stats from spectral samples
|
|
* @nfc_ctl_rssi: Control chan rssi
|
|
* @nfc_ext_rssi: Extension chan rssi
|
|
* @ctrl_nf: Control chan Noise Floor
|
|
* @ext_nf: Extension chan Noise Floor
|
|
*/
|
|
struct target_if_spectral_acs_stats {
|
|
int8_t nfc_ctl_rssi;
|
|
int8_t nfc_ext_rssi;
|
|
int8_t ctrl_nf;
|
|
int8_t ext_nf;
|
|
};
|
|
|
|
/**
|
|
* struct target_if_spectral_perchain_rssi_info - per chain rssi info
|
|
* @rssi_pri20: Rssi of primary 20 Mhz
|
|
* @rssi_sec20: Rssi of secondary 20 Mhz
|
|
* @rssi_sec40: Rssi of secondary 40 Mhz
|
|
* @rssi_sec80: Rssi of secondary 80 Mhz
|
|
*/
|
|
struct target_if_spectral_perchain_rssi_info {
|
|
int8_t rssi_pri20;
|
|
int8_t rssi_sec20;
|
|
int8_t rssi_sec40;
|
|
int8_t rssi_sec80;
|
|
};
|
|
|
|
/**
|
|
* struct target_if_spectral_rfqual_info - RF measurement information
|
|
* @rssi_comb: RSSI Information
|
|
* @pc_rssi_info: XXX : For now, we know we are getting information
|
|
* for only 4 chains at max. For future extensions
|
|
* use a define
|
|
* @noise_floor: Noise floor information
|
|
*/
|
|
struct target_if_spectral_rfqual_info {
|
|
int8_t rssi_comb;
|
|
struct target_if_spectral_perchain_rssi_info pc_rssi_info[4];
|
|
int16_t noise_floor[4];
|
|
};
|
|
|
|
#define GET_TARGET_IF_SPECTRAL_OPS(spectral) \
|
|
((struct target_if_spectral_ops *)(&((spectral)->spectral_ops)))
|
|
|
|
/**
|
|
* struct target_if_spectral_ops - spectral low level ops table
|
|
* @get_tsf64: Get 64 bit TSF value
|
|
* @get_capability: Get capability info
|
|
* @set_rxfilter: Set rx filter
|
|
* @get_rxfilter: Get rx filter
|
|
* @is_spectral_active: Check whether icm is active
|
|
* @is_spectral_enabled: Check whether spectral is enabled
|
|
* @start_spectral_scan: Start spectral scan
|
|
* @stop_spectral_scan: Stop spectral scan
|
|
* @get_extension_channel: Get extension channel
|
|
* @get_ctl_noisefloor: Get control noise floor
|
|
* @get_ext_noisefloor: Get extension noise floor
|
|
* @configure_spectral: Set spectral configurations
|
|
* @get_spectral_config: Get spectral configurations
|
|
* @get_ent_spectral_mask: Get spectral mask
|
|
* @get_mac_address: Get mac address
|
|
* @get_current_channel: Get current channel
|
|
* @reset_hw: Reset HW
|
|
* @get_chain_noise_floor: Get Channel noise floor
|
|
* @spectral_process_phyerr: Process phyerr event
|
|
* @process_spectral_report: Process spectral report
|
|
* @byte_swap_headers: Apply byte-swap on report headers
|
|
* @byte_swap_fft_bins: Apply byte-swap on FFT bins
|
|
*/
|
|
struct target_if_spectral_ops {
|
|
uint64_t (*get_tsf64)(void *arg);
|
|
uint32_t (*get_capability)(
|
|
void *arg, enum spectral_capability_type type);
|
|
uint32_t (*set_rxfilter)(void *arg, int rxfilter);
|
|
uint32_t (*get_rxfilter)(void *arg);
|
|
uint32_t (*is_spectral_active)(void *arg,
|
|
enum spectral_scan_mode smode);
|
|
uint32_t (*is_spectral_enabled)(void *arg,
|
|
enum spectral_scan_mode smode);
|
|
uint32_t (*start_spectral_scan)(void *arg,
|
|
enum spectral_scan_mode smode,
|
|
enum spectral_cp_error_code *err);
|
|
uint32_t (*stop_spectral_scan)(void *arg,
|
|
enum spectral_scan_mode smode);
|
|
uint32_t (*get_extension_channel)(void *arg,
|
|
enum spectral_scan_mode smode);
|
|
int8_t (*get_ctl_noisefloor)(void *arg);
|
|
int8_t (*get_ext_noisefloor)(void *arg);
|
|
uint32_t (*configure_spectral)(
|
|
void *arg,
|
|
struct spectral_config *params,
|
|
enum spectral_scan_mode smode);
|
|
uint32_t (*get_spectral_config)(
|
|
void *arg,
|
|
struct spectral_config *params,
|
|
enum spectral_scan_mode smode);
|
|
uint32_t (*get_ent_spectral_mask)(void *arg);
|
|
uint32_t (*get_mac_address)(void *arg, char *addr);
|
|
uint32_t (*get_current_channel)(void *arg,
|
|
enum spectral_scan_mode smode);
|
|
uint32_t (*reset_hw)(void *arg);
|
|
uint32_t (*get_chain_noise_floor)(void *arg, int16_t *nf_buf);
|
|
int (*spectral_process_phyerr)(struct target_if_spectral *spectral,
|
|
uint8_t *data, uint32_t datalen,
|
|
struct target_if_spectral_rfqual_info *p_rfqual,
|
|
struct target_if_spectral_chan_info *p_chaninfo,
|
|
uint64_t tsf64,
|
|
struct target_if_spectral_acs_stats *acs_stats);
|
|
int (*process_spectral_report)(struct wlan_objmgr_pdev *pdev,
|
|
void *payload);
|
|
QDF_STATUS (*byte_swap_headers)(
|
|
struct target_if_spectral *spectral,
|
|
void *data);
|
|
QDF_STATUS (*byte_swap_fft_bins)(
|
|
const struct spectral_report_params *rparams,
|
|
void *bin_pwr_data, size_t num_fftbins);
|
|
};
|
|
|
|
/**
|
|
* struct target_if_spectral_stats - spectral stats info
|
|
* @num_spectral_detects: Total num. of spectral detects
|
|
* @total_phy_errors: Total number of phyerrors
|
|
* @owl_phy_errors: Indicated phyerrors in old gen1 chipsets
|
|
* @pri_phy_errors: Phyerrors in primary channel
|
|
* @ext_phy_errors: Phyerrors in secondary channel
|
|
* @dc_phy_errors: Phyerrors due to dc
|
|
* @early_ext_phy_errors: Early secondary channel phyerrors
|
|
* @bwinfo_errors: Bandwidth info errors
|
|
* @datalen_discards: Invalid data length errors, seen in gen1 chipsets
|
|
* @rssi_discards: Indicates reports dropped due to RSSI threshold
|
|
* @last_reset_tstamp: Last reset time stamp
|
|
*/
|
|
struct target_if_spectral_stats {
|
|
uint32_t num_spectral_detects;
|
|
uint32_t total_phy_errors;
|
|
uint32_t owl_phy_errors;
|
|
uint32_t pri_phy_errors;
|
|
uint32_t ext_phy_errors;
|
|
uint32_t dc_phy_errors;
|
|
uint32_t early_ext_phy_errors;
|
|
uint32_t bwinfo_errors;
|
|
uint32_t datalen_discards;
|
|
uint32_t rssi_discards;
|
|
uint64_t last_reset_tstamp;
|
|
};
|
|
|
|
/**
|
|
* struct target_if_spectral_event - spectral event structure
|
|
* @se_ts: Original 15 bit recv timestamp
|
|
* @se_full_ts: 64-bit full timestamp from interrupt time
|
|
* @se_rssi: Rssi of spectral event
|
|
* @se_bwinfo: Rssi of spectral event
|
|
* @se_dur: Duration of spectral pulse
|
|
* @se_chanindex: Channel of event
|
|
* @se_list: List of spectral events
|
|
*/
|
|
struct target_if_spectral_event {
|
|
uint32_t se_ts;
|
|
uint64_t se_full_ts;
|
|
uint8_t se_rssi;
|
|
uint8_t se_bwinfo;
|
|
uint8_t se_dur;
|
|
uint8_t se_chanindex;
|
|
|
|
STAILQ_ENTRY(spectral_event) se_list;
|
|
};
|
|
|
|
/**
|
|
* struct target_if_chain_noise_pwr_info - Noise power info for each channel
|
|
* @rptcount: Count of reports in pwr array
|
|
* @un_cal_nf: Uncalibrated noise floor
|
|
* @factory_cal_nf: Noise floor as calibrated at the factory for module
|
|
* @median_pwr: Median power (median of pwr array)
|
|
* @pwr: Power reports
|
|
*/
|
|
struct target_if_chain_noise_pwr_info {
|
|
int rptcount;
|
|
pwr_dbm un_cal_nf;
|
|
pwr_dbm factory_cal_nf;
|
|
pwr_dbm median_pwr;
|
|
pwr_dbm pwr[];
|
|
} __ATTRIB_PACK;
|
|
|
|
/**
|
|
* struct target_if_spectral_chan_stats - Channel information
|
|
* @cycle_count: Cycle count
|
|
* @channel_load: Channel load
|
|
* @per: Period
|
|
* @noisefloor: Noise floor
|
|
* @comp_usablity: Computed usability
|
|
* @maxregpower: Maximum allowed regulatary power
|
|
* @comp_usablity_sec80: Computed usability of secondary 80 Mhz
|
|
* @maxregpower_sec80: Max regulatory power in secondary 80 Mhz
|
|
*/
|
|
struct target_if_spectral_chan_stats {
|
|
int cycle_count;
|
|
int channel_load;
|
|
int per;
|
|
int noisefloor;
|
|
uint16_t comp_usablity;
|
|
int8_t maxregpower;
|
|
uint16_t comp_usablity_sec80;
|
|
int8_t maxregpower_sec80;
|
|
};
|
|
|
|
#if ATH_PERF_PWR_OFFLOAD
|
|
|
|
/**
|
|
* struct target_if_spectral_cache - Cache used to minimize WMI operations
|
|
* in offload architecture
|
|
* @osc_spectral_enabled: Whether Spectral is enabled
|
|
* @osc_spectral_active: Whether spectral is active
|
|
* XXX: Ideally, we should NOT cache this
|
|
* since the hardware can self clear the bit,
|
|
* the firmware can possibly stop spectral due to
|
|
* intermittent off-channel activity, etc
|
|
* A WMI read command should be introduced to handle
|
|
* this This will be discussed.
|
|
* @osc_params: Spectral parameters
|
|
* @osc_is_valid: Whether the cache is valid
|
|
*/
|
|
struct target_if_spectral_cache {
|
|
uint8_t osc_spectral_enabled;
|
|
uint8_t osc_spectral_active;
|
|
struct spectral_config osc_params;
|
|
uint8_t osc_is_valid;
|
|
};
|
|
|
|
/**
|
|
* struct target_if_spectral_param_state_info - Structure used to represent and
|
|
* manage spectral information
|
|
* (parameters and states)
|
|
* @osps_lock: Lock to synchronize accesses to information
|
|
* @osps_cache: Cacheable' information
|
|
*/
|
|
struct target_if_spectral_param_state_info {
|
|
qdf_spinlock_t osps_lock;
|
|
struct target_if_spectral_cache osps_cache;
|
|
/* XXX - Non-cacheable information goes here, in the future */
|
|
};
|
|
#endif /* ATH_PERF_PWR_OFFLOAD */
|
|
|
|
struct vdev_spectral_configure_params;
|
|
struct vdev_spectral_enable_params;
|
|
|
|
/**
|
|
* struct spectral_wmi_ops - structure used holding the operations
|
|
* related to Spectral WMI
|
|
* @wmi_spectral_configure_cmd_send: Configure Spectral parameters
|
|
* @wmi_spectral_enable_cmd_send: Enable/Disable Spectral
|
|
* @wmi_spectral_crash_inject: Inject FW crash
|
|
* @wmi_extract_pdev_sscan_fw_cmd_fixed_param: Extract Fixed params from
|
|
* start scan response event
|
|
* @wmi_extract_pdev_sscan_fft_bin_index: Extract TLV which describes FFT
|
|
* bin indices from start scan response event
|
|
* @wmi_unified_register_event_handler: Register WMI event handler
|
|
* @wmi_unified_unregister_event_handler: Unregister WMI event handler
|
|
* @wmi_service_enabled: API to check whether a given WMI service is enabled
|
|
* @extract_pdev_spectral_session_chan_info: Extract Spectral scan session
|
|
* channel information
|
|
* @extract_pdev_spectral_session_detector_info: Extract Spectral scan session
|
|
* detector information
|
|
* @extract_spectral_caps_fixed_param: Extract fixed parameters from Spectral
|
|
* capabilities event
|
|
* @extract_spectral_scan_bw_caps: Extract bandwidth capabilities from Spectral
|
|
* capabilities event
|
|
* @extract_spectral_fft_size_caps: Extract fft size capabilities from Spectral
|
|
* capabilities event
|
|
*/
|
|
struct spectral_wmi_ops {
|
|
QDF_STATUS (*wmi_spectral_configure_cmd_send)(
|
|
wmi_unified_t wmi_hdl,
|
|
struct vdev_spectral_configure_params *param);
|
|
QDF_STATUS (*wmi_spectral_enable_cmd_send)(
|
|
wmi_unified_t wmi_hdl,
|
|
struct vdev_spectral_enable_params *param);
|
|
QDF_STATUS (*wmi_spectral_crash_inject)(
|
|
wmi_unified_t wmi_handle, struct crash_inject *param);
|
|
QDF_STATUS (*wmi_extract_pdev_sscan_fw_cmd_fixed_param)(
|
|
wmi_unified_t wmi_handle, uint8_t *evt_buf,
|
|
struct spectral_startscan_resp_params *param);
|
|
QDF_STATUS (*wmi_extract_pdev_sscan_fft_bin_index)(
|
|
wmi_unified_t wmi_handle, uint8_t *evt_buf,
|
|
struct spectral_fft_bin_markers_160_165mhz *param);
|
|
QDF_STATUS (*wmi_unified_register_event_handler)(
|
|
wmi_unified_t wmi_handle,
|
|
wmi_conv_event_id event_id,
|
|
wmi_unified_event_handler handler_func,
|
|
uint8_t rx_ctx);
|
|
QDF_STATUS (*wmi_unified_unregister_event_handler)(
|
|
wmi_unified_t wmi_handle,
|
|
wmi_conv_event_id event_id);
|
|
bool (*wmi_service_enabled)(wmi_unified_t wmi_handle,
|
|
uint32_t service_id);
|
|
QDF_STATUS (*extract_pdev_spectral_session_chan_info)(
|
|
wmi_unified_t wmi_handle, void *event,
|
|
struct spectral_session_chan_info *chan_info);
|
|
QDF_STATUS (*extract_pdev_spectral_session_detector_info)(
|
|
wmi_unified_t wmi_handle, void *event,
|
|
struct spectral_session_det_info *det_info,
|
|
uint8_t det_info_idx);
|
|
QDF_STATUS (*extract_spectral_caps_fixed_param)(
|
|
wmi_unified_t wmi_handle, void *event,
|
|
struct spectral_capabilities_event_params *param);
|
|
QDF_STATUS (*extract_spectral_scan_bw_caps)(
|
|
wmi_unified_t wmi_handle, void *event,
|
|
struct spectral_scan_bw_capabilities *bw_caps);
|
|
QDF_STATUS (*extract_spectral_fft_size_caps)(
|
|
wmi_unified_t wmi_handle, void *event,
|
|
struct spectral_fft_size_capabilities *fft_size_caps);
|
|
};
|
|
|
|
/**
|
|
* struct spectral_tgt_ops - structure used holding the operations
|
|
* related to target operations
|
|
* @tgt_get_psoc_from_scn_hdl: Function to get psoc from scn
|
|
*/
|
|
struct spectral_tgt_ops {
|
|
struct wlan_objmgr_psoc *(*tgt_get_psoc_from_scn_hdl)(void *scn_handle);
|
|
};
|
|
|
|
/**
|
|
* struct spectral_param_properties - structure holding Spectral
|
|
* parameter properties
|
|
* @supported: Parameter is supported or not
|
|
* @common_all_modes: Parameter should be common for all modes or not
|
|
*/
|
|
struct spectral_param_properties {
|
|
bool supported;
|
|
bool common_all_modes;
|
|
};
|
|
|
|
/**
|
|
* struct target_if_finite_spectral_scan_params - Parameters related to finite
|
|
* Spectral scan
|
|
* @finite_spectral_scan: Indicates the Spectrl scan is finite/infinite
|
|
* @num_reports_expected: Number of Spectral reports expected from target for a
|
|
* finite Spectral scan
|
|
*/
|
|
struct target_if_finite_spectral_scan_params {
|
|
bool finite_spectral_scan;
|
|
uint32_t num_reports_expected;
|
|
};
|
|
|
|
/**
|
|
* struct per_session_dest_det_info - Per-session Detector information to be
|
|
* filled to samp_detector_info
|
|
* @freq_span_id: Contiguous frequency span ID within the SAMP message
|
|
* @is_sec80: Indicates pri80/sec80 segment for 160/80p80 BW
|
|
* @det_id: Detector ID within samp_freq_span_info corresponding to
|
|
* freq_span_id
|
|
* @dest_start_bin_idx: Start index of FFT bins within SAMP msg's bin_pwr array
|
|
* @dest_end_bin_idx: End index of FFT bins within SAMP msg's bin_pwr array
|
|
* @lb_extrabins_start_idx: Left band edge extra bins start index
|
|
* @lb_extrabins_num: Number of left band edge extra bins
|
|
* @rb_extrabins_start_idx: Right band edge extra bins start index
|
|
* @rb_extrabins_num: Number of right band edge extra bins
|
|
* @start_freq: Indicates start frequency per-detector (in MHz)
|
|
* @end_freq: Indicates last frequency per-detector (in MHz)
|
|
* @src_start_bin_idx: Start index within the Spectral report's bin_pwr array,
|
|
* where the FFT bins corresponding to this dest_det_id start
|
|
*/
|
|
struct per_session_dest_det_info {
|
|
uint8_t freq_span_id;
|
|
bool is_sec80;
|
|
uint8_t det_id;
|
|
uint16_t dest_start_bin_idx;
|
|
uint16_t dest_end_bin_idx;
|
|
uint16_t lb_extrabins_start_idx;
|
|
uint16_t lb_extrabins_num;
|
|
uint16_t rb_extrabins_start_idx;
|
|
uint16_t rb_extrabins_num;
|
|
uint32_t start_freq;
|
|
uint32_t end_freq;
|
|
uint16_t src_start_bin_idx;
|
|
};
|
|
|
|
/**
|
|
* struct per_session_det_map - A map of per-session detector information,
|
|
* keyed by the detector id obtained from the Spectral FFT report, mapping to
|
|
* destination detector info in SAMP message.
|
|
* @dest_det_info: Struct containing per-session detector information
|
|
* @num_dest_det_info: Number of destination detectors to which information
|
|
* of this detector is to be filled
|
|
* @buf_type: Spectral message buffer type
|
|
* @send_to_upper_layers: Indicates whether to send SAMP msg to upper layers
|
|
* @det_map_valid: Indicates whether detector map is valid or not
|
|
*/
|
|
struct per_session_det_map {
|
|
struct per_session_dest_det_info
|
|
dest_det_info[MAX_NUM_DEST_DETECTOR_INFO];
|
|
uint8_t num_dest_det_info;
|
|
enum spectral_msg_buf_type buf_type;
|
|
bool send_to_upper_layers;
|
|
bool det_map_valid[SPECTRAL_SCAN_MODE_MAX];
|
|
};
|
|
|
|
/**
|
|
* struct per_session_report_info - Consists of per-session Spectral report
|
|
* information to be filled at report level in SAMP message.
|
|
* @pri20_freq: Primary 20MHz operating frequency in MHz
|
|
* @cfreq1: Centre frequency of the frequency span for 20/40/80 MHz BW.
|
|
* Segment 1 centre frequency in MHz for 80p80/160 BW.
|
|
* @cfreq2: For 80p80, indicates segment 2 centre frequency in MHz. For 160MHz,
|
|
* indicates the center frequency of 160MHz span.
|
|
* @operating_bw: Device's operating bandwidth.Valid values = enum phy_ch_width
|
|
* @sscan_cfreq1: Normal/Agile scan Centre frequency of the frequency span for
|
|
* 20/40/80 MHz BW. Center frequency of Primary Segment in MHz for 80p80/160 BW
|
|
* Based on Spectral scan mode.
|
|
* @sscan_cfreq2: For 80p80, Normal/Agile scan Center frequency for Sec80
|
|
* segment. For 160MHz, indicates the center frequency of 160MHz span. Based on
|
|
* spectral scan mode
|
|
* @sscan_bw: Normal/Agile Scan BW based on Spectral scan mode.
|
|
* Valid values = enum phy_ch_width
|
|
* @num_spans: Number of frequency spans
|
|
* @valid: Indicated whether report info is valid
|
|
*/
|
|
struct per_session_report_info {
|
|
uint32_t pri20_freq;
|
|
uint32_t cfreq1;
|
|
uint32_t cfreq2;
|
|
enum phy_ch_width operating_bw;
|
|
uint32_t sscan_cfreq1;
|
|
uint32_t sscan_cfreq2;
|
|
enum phy_ch_width sscan_bw;
|
|
uint8_t num_spans;
|
|
bool valid;
|
|
};
|
|
|
|
/**
|
|
* struct sscan_detector_list - Spectral scan Detector list, for given Spectral
|
|
* scan mode and operating BW
|
|
* @detectors: List of detectors
|
|
* @num_detectors: Number of detectors for given spectral scan mode, BW
|
|
* and target type
|
|
*/
|
|
struct sscan_detector_list {
|
|
uint8_t detectors[SPECTRAL_DETECTOR_ID_MAX];
|
|
uint8_t num_detectors;
|
|
};
|
|
|
|
/**
|
|
* struct spectral_supported_bws - Supported sscan bandwidths
|
|
* @supports_sscan_bw_5: 5 MHz bandwidth supported
|
|
* @supports_sscan_bw_10: 10 MHz bandwidth supported
|
|
* @supports_sscan_bw_20: 20 MHz bandwidth supported
|
|
* @supports_sscan_bw_40: 40 MHz bandwidth supported
|
|
* @supports_sscan_bw_80: 80 MHz bandwidth supported
|
|
* @supports_sscan_bw_160: 160 MHz bandwidth supported
|
|
* @supports_sscan_bw_80_80: 80+80 MHz bandwidth supported
|
|
* @supports_sscan_bw_320: 320 MHz bandwidth supported
|
|
* @reserved: reserved for future use
|
|
* @bandwidths: bitmap of supported sscan bandwidths. Make sure to maintain this
|
|
* bitmap in the increasing order of bandwidths.
|
|
*/
|
|
struct spectral_supported_bws {
|
|
union {
|
|
struct {
|
|
uint32_t supports_sscan_bw_5:1,
|
|
supports_sscan_bw_10:1,
|
|
supports_sscan_bw_20:1,
|
|
supports_sscan_bw_40:1,
|
|
supports_sscan_bw_80:1,
|
|
supports_sscan_bw_160:1,
|
|
supports_sscan_bw_80_80:1,
|
|
supports_sscan_bw_320:1,
|
|
reserved:24;
|
|
};
|
|
uint32_t bandwidths;
|
|
};
|
|
};
|
|
|
|
/**
|
|
* get_supported_sscan_bw_pos() - Get the position of a given sscan_bw inside
|
|
* the supported sscan bandwidths bitmap
|
|
* @sscan_bw: Spectral scan bandwidth
|
|
*
|
|
* Return: bit position for a valid sscan bandwidth, else -1
|
|
*/
|
|
int get_supported_sscan_bw_pos(enum phy_ch_width sscan_bw);
|
|
|
|
/**
|
|
* struct target_if_spectral - main spectral structure
|
|
* @pdev_obj: Pointer to pdev
|
|
* @spectral_ops: Target if internal Spectral low level operations table
|
|
* @capability: Spectral capabilities structure
|
|
* @properties: Spectral parameter properties per mode
|
|
* @spectral_lock: Lock used for internal Spectral operations
|
|
* @vdev_id: VDEV id for all spectral modes
|
|
* @spectral_curchan_radindex: Current channel spectral index
|
|
* @spectral_extchan_radindex: Extension channel spectral index
|
|
* @spectraldomain: Current Spectral domain
|
|
* @spectral_proc_phyerr: Flags to process for PHY errors
|
|
* @spectral_defaultparams: Default PHY params per Spectral stat
|
|
* @spectral_stats: Spectral related stats
|
|
* @events: Events structure
|
|
* @sc_spectral_ext_chan_ok: Can spectral be detected on the extension channel?
|
|
* @sc_spectral_combined_rssi_ok: Can use combined spectral RSSI?
|
|
* @sc_spectral_20_40_mode: Is AP in 20-40 mode?
|
|
* @sc_spectral_noise_pwr_cal: Noise power cal required?
|
|
* @sc_spectral_non_edma: Is the spectral capable device Non-EDMA?
|
|
* @upper_is_control: Upper segment is primary
|
|
* @upper_is_extension: Upper segment is secondary
|
|
* @lower_is_control: Lower segment is primary
|
|
* @lower_is_extension: Lower segment is secondary
|
|
* @sc_spectraltest_ieeechan: IEEE channel number to return to after a spectral
|
|
* mute test
|
|
* @spectral_numbins: Number of bins
|
|
* @spectral_fft_len: FFT length
|
|
* @spectral_data_len: Total phyerror report length
|
|
* @lb_edge_extrabins: Number of extra bins on left band edge
|
|
* @rb_edge_extrabins: Number of extra bins on right band edge
|
|
* @spectral_max_index_offset: Max FFT index offset (20 MHz mode)
|
|
* @spectral_upper_max_index_offset: Upper max FFT index offset (20/40 MHz mode)
|
|
* @spectral_lower_max_index_offset: Lower max FFT index offset (20/40 MHz mode)
|
|
* @spectral_dc_index: At which index DC is present
|
|
* @send_single_packet: Deprecated
|
|
* @spectral_sent_msg: Indicates whether we send report to upper layers
|
|
* @classify_scan:
|
|
* @classify_timer:
|
|
* @params: Spectral parameters
|
|
* @params_valid:
|
|
* @classifier_params:
|
|
* @last_capture_time: Indicates timestamp of previous report
|
|
* @num_spectral_data: Number of Spectral samples received in current session
|
|
* @total_spectral_data: Total number of Spectral samples received
|
|
* @max_rssi: Maximum RSSI
|
|
* @detects_control_channel: NA
|
|
* @detects_extension_channel: NA
|
|
* @detects_below_dc: NA
|
|
* @detects_above_dc: NA
|
|
* @sc_scanning: Indicates active wifi scan
|
|
* @sc_spectral_scan: Indicates active specral scan
|
|
* @sc_spectral_full_scan: Deprecated
|
|
* @scan_start_tstamp: Deprecated
|
|
* @last_tstamp: Deprecated
|
|
* @first_tstamp: Deprecated
|
|
* @spectral_samp_count: Deprecated
|
|
* @sc_spectral_samp_count: Deprecated
|
|
* @noise_pwr_reports_reqd: Number of noise power reports required
|
|
* @noise_pwr_reports_recv: Number of noise power reports received
|
|
* @noise_pwr_reports_lock: Lock used for Noise power report processing
|
|
* @noise_pwr_chain_ctl: Noise power report - control channel
|
|
* @noise_pwr_chain_ext: Noise power report - extension channel
|
|
* @tsf64: Latest TSF Value
|
|
* @param_info: Offload architecture Spectral parameter cache information
|
|
* @ch_width: Indicates Channel Width 20/40/80/160 MHz for each Spectral mode
|
|
* @sscan_width_configured: Whether user has configured sscan bandwidth
|
|
* @diag_stats: Diagnostic statistics
|
|
* @is_160_format: Indicates whether information provided by HW is in altered
|
|
* format for 802.11ac 160/80+80 MHz support (QCA9984 onwards)
|
|
* @is_lb_edge_extrabins_format: Indicates whether information provided by
|
|
* HW has 4 extra bins, at left band edge, for report mode 2
|
|
* @is_rb_edge_extrabins_format: Indicates whether information provided
|
|
* by HW has 4 extra bins, at right band edge, for report mode 2
|
|
* @is_sec80_rssi_war_required: Indicates whether the software workaround is
|
|
* required to obtain approximate combined RSSI for secondary 80Mhz segment
|
|
* @simctx: Spectral Simulation context
|
|
* @spectral_gen: Spectral hardware generation
|
|
* @hdr_sig_exp: Expected signature in PHYERR TLV header, for the given hardware
|
|
* generation
|
|
* @tag_sscan_summary_exp: Expected Spectral Scan Summary tag in PHYERR TLV
|
|
* header, for the given hardware generation
|
|
* @tag_sscan_fft_exp: Expected Spectral Scan FFT report tag in PHYERR TLV
|
|
* header, for the given hardware generation
|
|
* @tlvhdr_size: Expected PHYERR TLV header size, for the given hardware
|
|
* generation
|
|
* @nl_cb: Netlink callbacks
|
|
* @use_nl_bcast: Whether to use Netlink broadcast/unicast
|
|
* @send_phy_data: Send data to the application layer for a particular msg type
|
|
* @len_adj_swar: Spectral fft bin length adjustment SWAR related info
|
|
* @timestamp_war: Spectral time stamp WAR related info
|
|
* @state_160mhz_delivery: Delivery state for each spectral scan mode
|
|
* @dbr_ring_debug: Whether Spectral DBR ring debug is enabled
|
|
* @dbr_buff_debug: Whether Spectral DBR buffer debug is enabled
|
|
* @direct_dma_support: Whether Direct-DMA is supported on the current radio
|
|
* @prev_tstamp: Timestamp of the previously received sample, which has to be
|
|
* compared with the current tstamp to check descrepancy
|
|
* @rparams: Parameters related to Spectral report structure
|
|
* @param_min_max: Spectral parameter's minimum and maximum values
|
|
* @finite_scan: Parameters for finite Spectral scan
|
|
* @detector_list: Detector list for a given Spectral scan mode and channel
|
|
* width, based on the target type.
|
|
* @detector_list_lock: Lock to synchronize accesses to detector list
|
|
* @det_map: Map of per-session detector information keyed by the Spectral HW
|
|
* detector id.
|
|
* @session_det_map_lock: Lock to synchronize accesses to session detector map
|
|
* @report_info: Per session info to be filled at report level in SAMP message
|
|
* @session_report_info_lock: Lock to synchronize access to session report info
|
|
* @supported_bws: Supported sscan bandwidths for all sscan modes and
|
|
* operating widths
|
|
* @supported_sscan_bw_list: List of supported sscan widths for all sscan modes
|
|
* @data_stats: stats in Spectral data path
|
|
*/
|
|
struct target_if_spectral {
|
|
struct wlan_objmgr_pdev *pdev_obj;
|
|
struct target_if_spectral_ops spectral_ops;
|
|
struct spectral_caps capability;
|
|
struct spectral_param_properties
|
|
properties[SPECTRAL_SCAN_MODE_MAX][SPECTRAL_PARAM_MAX];
|
|
qdf_spinlock_t spectral_lock;
|
|
uint8_t vdev_id[SPECTRAL_SCAN_MODE_MAX];
|
|
int16_t spectral_curchan_radindex;
|
|
int16_t spectral_extchan_radindex;
|
|
uint32_t spectraldomain;
|
|
uint32_t spectral_proc_phyerr;
|
|
struct spectral_config spectral_defaultparams;
|
|
struct target_if_spectral_stats spectral_stats;
|
|
struct target_if_spectral_event *events;
|
|
unsigned int sc_spectral_ext_chan_ok:1,
|
|
sc_spectral_combined_rssi_ok:1,
|
|
sc_spectral_20_40_mode:1,
|
|
sc_spectral_noise_pwr_cal:1,
|
|
sc_spectral_non_edma:1;
|
|
int upper_is_control;
|
|
int upper_is_extension;
|
|
int lower_is_control;
|
|
int lower_is_extension;
|
|
uint8_t sc_spectraltest_ieeechan;
|
|
int spectral_numbins;
|
|
int spectral_fft_len;
|
|
int spectral_data_len;
|
|
|
|
/*
|
|
* For 11ac chipsets prior to AR900B version 2.0, a max of 512 bins are
|
|
* delivered. However, there can be additional bins reported for
|
|
* AR900B version 2.0 and QCA9984 as described next:
|
|
*
|
|
* AR900B version 2.0: An additional tone is processed on the right
|
|
* hand side in order to facilitate detection of radar pulses out to
|
|
* the extreme band-edge of the channel frequency. Since the HW design
|
|
* processes four tones at a time, this requires one additional Dword
|
|
* to be added to the search FFT report.
|
|
*
|
|
* QCA9984: When spectral_scan_rpt_mode = 2, i.e 2-dword summary +
|
|
* 1x-oversampled bins (in-band) per FFT, then 8 more bins
|
|
* (4 more on left side and 4 more on right side)are added.
|
|
*/
|
|
|
|
int lb_edge_extrabins;
|
|
int rb_edge_extrabins;
|
|
int spectral_max_index_offset;
|
|
int spectral_upper_max_index_offset;
|
|
int spectral_lower_max_index_offset;
|
|
int spectral_dc_index;
|
|
int send_single_packet;
|
|
int spectral_sent_msg;
|
|
int classify_scan;
|
|
qdf_timer_t classify_timer;
|
|
struct spectral_config params[SPECTRAL_SCAN_MODE_MAX];
|
|
bool params_valid[SPECTRAL_SCAN_MODE_MAX];
|
|
struct spectral_classifier_params classifier_params;
|
|
int last_capture_time;
|
|
int num_spectral_data;
|
|
int total_spectral_data;
|
|
int max_rssi;
|
|
int detects_control_channel;
|
|
int detects_extension_channel;
|
|
int detects_below_dc;
|
|
int detects_above_dc;
|
|
int sc_scanning;
|
|
int sc_spectral_scan;
|
|
int sc_spectral_full_scan;
|
|
uint64_t scan_start_tstamp;
|
|
uint32_t last_tstamp;
|
|
uint32_t first_tstamp;
|
|
uint32_t spectral_samp_count;
|
|
uint32_t sc_spectral_samp_count;
|
|
int noise_pwr_reports_reqd;
|
|
int noise_pwr_reports_recv;
|
|
qdf_spinlock_t noise_pwr_reports_lock;
|
|
struct target_if_chain_noise_pwr_info
|
|
*noise_pwr_chain_ctl[HOST_MAX_ANTENNA];
|
|
struct target_if_chain_noise_pwr_info
|
|
*noise_pwr_chain_ext[HOST_MAX_ANTENNA];
|
|
uint64_t tsf64;
|
|
#if ATH_PERF_PWR_OFFLOAD
|
|
struct target_if_spectral_param_state_info
|
|
param_info[SPECTRAL_SCAN_MODE_MAX];
|
|
#endif
|
|
enum phy_ch_width ch_width[SPECTRAL_SCAN_MODE_MAX];
|
|
bool sscan_width_configured[SPECTRAL_SCAN_MODE_MAX];
|
|
struct spectral_diag_stats diag_stats;
|
|
bool is_160_format;
|
|
bool is_lb_edge_extrabins_format;
|
|
bool is_rb_edge_extrabins_format;
|
|
bool is_sec80_rssi_war_required;
|
|
#ifdef QCA_SUPPORT_SPECTRAL_SIMULATION
|
|
void *simctx;
|
|
#endif
|
|
enum spectral_gen spectral_gen;
|
|
uint8_t hdr_sig_exp;
|
|
uint8_t tag_sscan_summary_exp;
|
|
uint8_t tag_sscan_fft_exp;
|
|
uint8_t tlvhdr_size;
|
|
struct spectral_nl_cb nl_cb;
|
|
bool use_nl_bcast;
|
|
int (*send_phy_data)(struct wlan_objmgr_pdev *pdev,
|
|
enum spectral_msg_type smsg_type);
|
|
struct spectral_fft_bin_len_adj_swar len_adj_swar;
|
|
struct spectral_timestamp_war timestamp_war;
|
|
enum spectral_160mhz_report_delivery_state
|
|
state_160mhz_delivery[SPECTRAL_SCAN_MODE_MAX];
|
|
bool dbr_ring_debug;
|
|
bool dbr_buff_debug;
|
|
bool direct_dma_support;
|
|
#ifdef OPTIMIZED_SAMP_MESSAGE
|
|
uint32_t prev_tstamp[MAX_DETECTORS_PER_PDEV];
|
|
#else
|
|
uint32_t prev_tstamp;
|
|
#endif
|
|
struct spectral_report_params rparams;
|
|
struct spectral_param_min_max param_min_max;
|
|
struct target_if_finite_spectral_scan_params
|
|
finite_scan[SPECTRAL_SCAN_MODE_MAX];
|
|
struct sscan_detector_list
|
|
detector_list[SPECTRAL_SCAN_MODE_MAX][CH_WIDTH_MAX];
|
|
qdf_spinlock_t detector_list_lock;
|
|
struct per_session_det_map det_map[MAX_DETECTORS_PER_PDEV];
|
|
qdf_spinlock_t session_det_map_lock;
|
|
struct per_session_report_info report_info[SPECTRAL_SCAN_MODE_MAX];
|
|
qdf_spinlock_t session_report_info_lock;
|
|
struct spectral_supported_bws
|
|
supported_bws[SPECTRAL_SCAN_MODE_MAX][CH_WIDTH_MAX];
|
|
/* Whether a given sscan BW is supported on a given smode */
|
|
bool supported_sscan_bw_list[SPECTRAL_SCAN_MODE_MAX][CH_WIDTH_MAX];
|
|
struct spectral_data_stats data_stats;
|
|
};
|
|
|
|
/**
|
|
* struct target_if_psoc_spectral - Target if psoc Spectral object
|
|
* @psoc_obj: psoc object
|
|
* @wmi_ops: Spectral WMI operations
|
|
*/
|
|
struct target_if_psoc_spectral {
|
|
struct wlan_objmgr_psoc *psoc_obj;
|
|
struct spectral_wmi_ops wmi_ops;
|
|
};
|
|
|
|
#ifdef OPTIMIZED_SAMP_MESSAGE
|
|
/**
|
|
* struct target_if_samp_msg_params - Spectral Analysis Messaging Protocol
|
|
* data format
|
|
* @hw_detector_id: Spectral HW detector ID
|
|
* @rssi: Spectral RSSI
|
|
* @lower_rssi: RSSI of lower band
|
|
* @upper_rssi: RSSI of upper band
|
|
* @chain_ctl_rssi: RSSI for control channel, for all antennas
|
|
* @chain_ext_rssi: RSSI for extension channel, for all antennas
|
|
* @last_raw_timestamp: Previous FFT report's raw timestamp.
|
|
* @raw_timestamp: FFT timestamp reported by HW on primary segment.
|
|
* @timestamp: timestamp
|
|
* @reset_delay: Time gap between the last spectral report before reset and the
|
|
* end of reset.
|
|
* @max_mag: maximum magnitude
|
|
* @max_index: index of max magnitude
|
|
* @noise_floor: current noise floor
|
|
* @agc_total_gain: AGC total gain on primary channel
|
|
* @gainchange: Indicates a gainchange occurred during the spectral scan
|
|
* @pri80ind: Indication from hardware that the sample was received on the
|
|
* primary 80 MHz segment. If this is set when smode =
|
|
* SPECTRAL_SCAN_MODE_AGILE, it indicates that Spectral was carried
|
|
* out on pri80 instead of the Agile frequency due to a channel
|
|
* switch - Software may choose to ignore the sample in this case.
|
|
* @blanking_status: Indicates whether scan blanking was enabled during this
|
|
* spectral report capture.
|
|
* @bin_pwr_data: Contains FFT magnitudes
|
|
*/
|
|
struct target_if_samp_msg_params {
|
|
uint8_t hw_detector_id;
|
|
int8_t rssi;
|
|
int8_t lower_rssi;
|
|
int8_t upper_rssi;
|
|
int8_t chain_ctl_rssi[HOST_MAX_ANTENNA];
|
|
int8_t chain_ext_rssi[HOST_MAX_ANTENNA];
|
|
uint32_t last_raw_timestamp;
|
|
uint32_t raw_timestamp;
|
|
uint32_t timestamp;
|
|
uint32_t reset_delay;
|
|
uint16_t max_mag;
|
|
uint16_t max_index;
|
|
int16_t noise_floor;
|
|
uint8_t agc_total_gain;
|
|
uint8_t gainchange;
|
|
uint8_t pri80ind;
|
|
uint8_t blanking_status;
|
|
uint8_t *bin_pwr_data;
|
|
};
|
|
|
|
#else
|
|
/**
|
|
* struct target_if_samp_msg_params - Spectral Analysis Messaging Protocol
|
|
* data format
|
|
* @rssi: RSSI (except for secondary 80 segment)
|
|
* @rssi_sec80: RSSI for secondary 80 segment
|
|
* @lower_rssi: RSSI of lower band
|
|
* @upper_rssi: RSSI of upper band
|
|
* @chain_ctl_rssi: RSSI for control channel, for all antennas
|
|
* @chain_ext_rssi: RSSI for extension channel, for all antennas
|
|
* @bwinfo: bandwidth info
|
|
* @datalen: length of FFT data (except for secondary 80 segment)
|
|
* @datalen_sec80: length of FFT data for secondary 80 segment
|
|
* @tstamp: timestamp
|
|
* @last_tstamp: last time stamp
|
|
* @max_mag: maximum magnitude (except for secondary 80 segment)
|
|
* @max_mag_sec80: maximum magnitude for secondary 80 segment
|
|
* @max_index: index of max magnitude (except for secondary 80 segment)
|
|
* @max_index_sec80: index of max magnitude for secondary 80 segment
|
|
* @max_exp: max exp
|
|
* @peak: peak frequency (obsolete)
|
|
* @pwr_count: number of FFT bins (except for secondary 80 segment)
|
|
* @pwr_count_5mhz: number of FFT bins in extra 5 MHz in
|
|
* 165 MHz/restricted 80p80 mode
|
|
* @pwr_count_sec80: number of FFT bins in secondary 80 segment
|
|
* @nb_lower: This is deprecated
|
|
* @nb_upper: This is deprecated
|
|
* @max_upper_index: index of max mag in upper band
|
|
* @max_lower_index: index of max mag in lower band
|
|
* @bin_pwr_data: Contains FFT magnitudes (except for secondary 80 segment)
|
|
* @bin_pwr_data_5mhz: Contains FFT magnitudes for the extra 5 MHz
|
|
* in 165 MHz/restricted 80p80 mode
|
|
* @bin_pwr_data_sec80: Contains FFT magnitudes for the secondary 80 segment
|
|
* @freq: Center frequency of primary 20MHz channel in MHz
|
|
* @vhtop_ch_freq_seg1: VHT operation first segment center frequency in MHz
|
|
* @vhtop_ch_freq_seg2: VHT operation second segment center frequency in MHz
|
|
* @agile_freq1: Center frequency in MHz of the entire span(for 80+80 MHz
|
|
* agile Scan it is primary 80 MHz span) across which
|
|
* Agile Spectral is carried out. Applicable only for Agile
|
|
* Spectral samples.
|
|
* @agile_freq2: Center frequency in MHz of the secondary 80 MHz span
|
|
* across which Agile Spectral is carried out. Applicable
|
|
* only for Agile Spectral samples in 80+80 MHz mode.
|
|
* @freq_loading: spectral control duty cycles
|
|
* @noise_floor: current noise floor (except for secondary 80 segment)
|
|
* @noise_floor_sec80: current noise floor for secondary 80 segment
|
|
* @interf_list: List of interference sources
|
|
* @classifier_params: classifier parameters
|
|
* @sc: classifier parameters
|
|
* @agc_total_gain: AGC total gain on primary channel
|
|
* @agc_total_gain_sec80: AGC total gain on secondary channel
|
|
* @gainchange: Indicates a gainchange occurred during the spectral scan
|
|
* @gainchange_sec80: Indicates a gainchange occurred in the secondary
|
|
* channel during the spectral scan
|
|
* @smode: spectral scan mode
|
|
* @pri80ind: Indication from hardware that the sample was received on the
|
|
* primary 80 MHz segment. If this is set when smode =
|
|
* SPECTRAL_SCAN_MODE_AGILE, it indicates that Spectral was carried out on
|
|
* pri80 instead of the Agile frequency due to a channel switch - Software may
|
|
* choose to ignore the sample in this case.
|
|
* @pri80ind_sec80: Indication from hardware that the sample was received on the
|
|
* primary 80 MHz segment instead of the secondary 80 MHz segment due to a
|
|
* channel switch - Software may choose to ignore the sample if this is set.
|
|
* Applicable only if smode = SPECTRAL_SCAN_MODE_NORMAL and for 160/80+80 MHz
|
|
* Spectral operation and if the chipset supports fragmented 160/80+80 MHz
|
|
* operation.
|
|
* @last_raw_timestamp: Previous FFT report's raw timestamp. In case of 160MHz
|
|
* it will be primary 80 segment's timestamp as both primary & secondary
|
|
* segment's timestamps are expected to be almost equal
|
|
* @timestamp_war_offset: Offset calculated based on reset_delay and
|
|
* last_raw_stamp. It will be added to raw_timestamp to get tstamp.
|
|
* @raw_timestamp: FFT timestamp reported by HW on primary segment.
|
|
* @raw_timestamp_sec80: FFT timestamp reported by HW on secondary 80 segment.
|
|
* @reset_delay: Time gap between the last spectral report before reset and the
|
|
* end of reset.
|
|
* @target_reset_count: Indicates the the number of times the target went
|
|
* through reset routine after spectral was enabled.
|
|
*/
|
|
struct target_if_samp_msg_params {
|
|
int8_t rssi;
|
|
int8_t rssi_sec80;
|
|
int8_t lower_rssi;
|
|
int8_t upper_rssi;
|
|
int8_t chain_ctl_rssi[HOST_MAX_ANTENNA];
|
|
int8_t chain_ext_rssi[HOST_MAX_ANTENNA];
|
|
uint16_t bwinfo;
|
|
uint16_t datalen;
|
|
uint16_t datalen_sec80;
|
|
uint32_t tstamp;
|
|
uint32_t last_tstamp;
|
|
uint16_t max_mag;
|
|
uint16_t max_mag_sec80;
|
|
uint16_t max_index;
|
|
uint16_t max_index_sec80;
|
|
uint8_t max_exp;
|
|
int peak;
|
|
int pwr_count;
|
|
int pwr_count_5mhz;
|
|
int pwr_count_sec80;
|
|
int8_t nb_lower;
|
|
int8_t nb_upper;
|
|
uint16_t max_lower_index;
|
|
uint16_t max_upper_index;
|
|
uint8_t *bin_pwr_data;
|
|
uint8_t *bin_pwr_data_5mhz;
|
|
uint8_t *bin_pwr_data_sec80;
|
|
uint16_t freq;
|
|
uint16_t vhtop_ch_freq_seg1;
|
|
uint16_t vhtop_ch_freq_seg2;
|
|
uint16_t agile_freq1;
|
|
uint16_t agile_freq2;
|
|
uint16_t freq_loading;
|
|
int16_t noise_floor;
|
|
int16_t noise_floor_sec80;
|
|
struct interf_src_rsp interf_list;
|
|
struct spectral_classifier_params classifier_params;
|
|
struct ath_softc *sc;
|
|
uint8_t agc_total_gain;
|
|
uint8_t agc_total_gain_sec80;
|
|
uint8_t gainchange;
|
|
uint8_t gainchange_sec80;
|
|
enum spectral_scan_mode smode;
|
|
uint8_t pri80ind;
|
|
uint8_t pri80ind_sec80;
|
|
uint32_t last_raw_timestamp;
|
|
uint32_t timestamp_war_offset;
|
|
uint32_t raw_timestamp;
|
|
uint32_t raw_timestamp_sec80;
|
|
uint32_t reset_delay;
|
|
uint32_t target_reset_count;
|
|
};
|
|
#endif
|
|
|
|
/**
|
|
* struct target_if_spectral_agile_mode_cap - Structure to hold agile
|
|
* Spetcral scan capability
|
|
* @agile_spectral_cap: agile Spectral scan capability for 20/40/80 MHz
|
|
* @agile_spectral_cap_160: agile Spectral scan capability for 160 MHz
|
|
* @agile_spectral_cap_80p80: agile Spectral scan capability for 80+80 MHz
|
|
* @agile_spectral_cap_320: agile Spectral scan capability for 320 MHz
|
|
*/
|
|
struct target_if_spectral_agile_mode_cap {
|
|
bool agile_spectral_cap;
|
|
bool agile_spectral_cap_160;
|
|
bool agile_spectral_cap_80p80;
|
|
bool agile_spectral_cap_320;
|
|
};
|
|
|
|
#ifdef WLAN_CONV_SPECTRAL_ENABLE
|
|
/**
|
|
* target_if_spectral_dump_fft() - Dump Spectral FFT
|
|
* @pfft: Pointer to Spectral Phyerr FFT
|
|
* @fftlen: FFT length
|
|
*
|
|
* Return: Success or failure
|
|
*/
|
|
int target_if_spectral_dump_fft(uint8_t *pfft, int fftlen);
|
|
|
|
/**
|
|
* target_if_dbg_print_samp_param() - Print contents of SAMP struct
|
|
* @p: Pointer to SAMP message
|
|
*
|
|
* Return: Void
|
|
*/
|
|
void target_if_dbg_print_samp_param(struct target_if_samp_msg_params *p);
|
|
|
|
/**
|
|
* target_if_get_offset_swar_sec80() - Get offset for SWAR according to
|
|
* the channel width
|
|
* @channel_width: Channel width
|
|
*
|
|
* Return: Offset for SWAR
|
|
*/
|
|
uint32_t target_if_get_offset_swar_sec80(uint32_t channel_width);
|
|
|
|
/**
|
|
* target_if_sptrl_register_tx_ops() - Register Spectral target_if Tx Ops
|
|
* @tx_ops: Tx Ops
|
|
*
|
|
* Return: void
|
|
*/
|
|
void target_if_sptrl_register_tx_ops(struct wlan_lmac_if_tx_ops *tx_ops);
|
|
|
|
#ifndef OPTIMIZED_SAMP_MESSAGE
|
|
/**
|
|
* target_if_spectral_create_samp_msg() - Create the spectral samp message
|
|
* @spectral : Pointer to spectral internal structure
|
|
* @params : spectral samp message parameters
|
|
*
|
|
* API to create the spectral samp message
|
|
*
|
|
* Return: void
|
|
*/
|
|
void target_if_spectral_create_samp_msg(
|
|
struct target_if_spectral *spectral,
|
|
struct target_if_samp_msg_params *params);
|
|
#endif
|
|
|
|
#ifdef OPTIMIZED_SAMP_MESSAGE
|
|
/**
|
|
* target_if_spectral_fill_samp_msg() - Fill the Spectral SAMP message
|
|
* @spectral : Pointer to spectral internal structure
|
|
* @params: Spectral SAMP message fields
|
|
*
|
|
* Fill the spectral SAMP message fields using params and detector map.
|
|
*
|
|
* Return: Success/Failure
|
|
*/
|
|
QDF_STATUS target_if_spectral_fill_samp_msg(
|
|
struct target_if_spectral *spectral,
|
|
struct target_if_samp_msg_params *params);
|
|
#endif
|
|
|
|
/**
|
|
* target_if_spectral_process_report_gen3() - Process spectral report for gen3
|
|
* @pdev: Pointer to pdev object
|
|
* @buf: Pointer to spectral report
|
|
*
|
|
* Process phyerror event for gen3
|
|
*
|
|
* Return: Success/Failure
|
|
*/
|
|
int target_if_spectral_process_report_gen3(struct wlan_objmgr_pdev *pdev,
|
|
void *buf);
|
|
|
|
/**
|
|
* target_if_process_phyerr_gen2() - Process PHY Error for gen2
|
|
* @spectral: Pointer to Spectral object
|
|
* @data: Pointer to phyerror event buffer
|
|
* @datalen: Data length
|
|
* @p_rfqual: RF quality info
|
|
* @p_chaninfo: Channel info
|
|
* @tsf64: 64 bit tsf timestamp
|
|
* @acs_stats: ACS stats
|
|
*
|
|
* Process PHY Error for gen2
|
|
*
|
|
* Return: Success/Failure
|
|
*/
|
|
int target_if_process_phyerr_gen2(
|
|
struct target_if_spectral *spectral,
|
|
uint8_t *data,
|
|
uint32_t datalen, struct target_if_spectral_rfqual_info *p_rfqual,
|
|
struct target_if_spectral_chan_info *p_chaninfo,
|
|
uint64_t tsf64,
|
|
struct target_if_spectral_acs_stats *acs_stats);
|
|
|
|
/**
|
|
* target_if_spectral_send_intf_found_msg() - Indicate to application layer that
|
|
* interference has been found
|
|
* @pdev: Pointer to pdev
|
|
* @cw_int: 1 if CW interference is found, 0 if WLAN interference is found
|
|
* @dcs_enabled: 1 if DCS is enabled, 0 if DCS is disabled
|
|
*
|
|
* Send message to application layer
|
|
* indicating that interference has been found
|
|
*
|
|
* Return: None
|
|
*/
|
|
void target_if_spectral_send_intf_found_msg(
|
|
struct wlan_objmgr_pdev *pdev,
|
|
uint16_t cw_int, uint32_t dcs_enabled);
|
|
|
|
/**
|
|
* target_if_stop_spectral_scan() - Stop spectral scan
|
|
* @pdev: Pointer to pdev object
|
|
* @smode: Spectral scan mode
|
|
* @err: Pointer to error code
|
|
*
|
|
* API to stop the current on-going spectral scan
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS in case of success, else QDF_STATUS_E_FAILURE
|
|
*/
|
|
QDF_STATUS target_if_stop_spectral_scan(struct wlan_objmgr_pdev *pdev,
|
|
const enum spectral_scan_mode smode,
|
|
enum spectral_cp_error_code *err);
|
|
|
|
/**
|
|
* target_if_spectral_get_vdev() - Get pointer to vdev to be used for Spectral
|
|
* operations
|
|
* @spectral: Pointer to Spectral target_if internal private data
|
|
* @smode: spectral scan mode
|
|
*
|
|
* Spectral operates on pdev. However, in order to retrieve some WLAN
|
|
* properties, a vdev is required. To facilitate this, the function returns the
|
|
* first vdev in our pdev. The caller should release the reference to the vdev
|
|
* once it is done using it.
|
|
* TODO: If the framework later provides an API to obtain the first active
|
|
* vdev, then it would be preferable to use this API.
|
|
*
|
|
* Return: Pointer to vdev on success, NULL on failure
|
|
*/
|
|
struct wlan_objmgr_vdev *target_if_spectral_get_vdev(
|
|
struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode);
|
|
|
|
/**
|
|
* target_if_spectral_dump_hdr_gen2() - Dump Spectral header for gen2
|
|
* @phdr: Pointer to Spectral Phyerr Header
|
|
*
|
|
* Dump Spectral header
|
|
*
|
|
* Return: Success/Failure
|
|
*/
|
|
int target_if_spectral_dump_hdr_gen2(struct spectral_phyerr_hdr_gen2 *phdr);
|
|
|
|
/**
|
|
* target_if_get_combrssi_sec80_seg_gen2() - Get approximate combined RSSI
|
|
* for Secondary 80 segment
|
|
* @spectral: Pointer to spectral object
|
|
* @p_sfft_sec80: Pointer to search fft info of secondary 80 segment
|
|
*
|
|
* Get approximate combined RSSI for Secondary 80 segment
|
|
*
|
|
* Return: Combined RSSI for secondary 80Mhz segment
|
|
*/
|
|
int8_t target_if_get_combrssi_sec80_seg_gen2(
|
|
struct target_if_spectral *spectral,
|
|
struct spectral_search_fft_info_gen2 *p_sfft_sec80);
|
|
|
|
/**
|
|
* target_if_spectral_dump_tlv_gen2() - Dump Spectral TLV for gen2
|
|
* @ptlv: Pointer to Spectral Phyerr TLV
|
|
* @is_160_format: Indicates 160 format
|
|
*
|
|
* Dump Spectral TLV for gen2
|
|
*
|
|
* Return: Success/Failure
|
|
*/
|
|
int target_if_spectral_dump_tlv_gen2(
|
|
struct spectral_phyerr_tlv_gen2 *ptlv, bool is_160_format);
|
|
|
|
/**
|
|
* target_if_spectral_dump_phyerr_data_gen2() - Dump Spectral
|
|
* related PHY Error for gen2
|
|
* @data: Pointer to phyerror buffer
|
|
* @datalen: Data length
|
|
* @is_160_format: Indicates 160 format
|
|
*
|
|
* Dump Spectral related PHY Error for gen2
|
|
*
|
|
* Return: Success/Failure
|
|
*/
|
|
int target_if_spectral_dump_phyerr_data_gen2(
|
|
uint8_t *data,
|
|
uint32_t datalen,
|
|
bool is_160_format);
|
|
|
|
/**
|
|
* target_if_dbg_print_samp_msg() - Print contents of SAMP Message
|
|
* @pmsg: Pointer to SAMP message
|
|
*
|
|
* Print contents of SAMP Message
|
|
*
|
|
* Return: Void
|
|
*/
|
|
void target_if_dbg_print_samp_msg(struct spectral_samp_msg *pmsg);
|
|
|
|
/**
|
|
* get_target_if_spectral_handle_from_pdev() - Get handle to target_if internal
|
|
* Spectral data
|
|
* @pdev: Pointer to pdev
|
|
*
|
|
* Return: Handle to target_if internal Spectral data on success, NULL on
|
|
* failure
|
|
*/
|
|
struct target_if_spectral *get_target_if_spectral_handle_from_pdev(
|
|
struct wlan_objmgr_pdev *pdev);
|
|
|
|
/**
|
|
* get_target_if_spectral_handle_from_psoc() - Get handle to psoc target_if
|
|
* internal Spectral data
|
|
* @psoc: Pointer to psoc
|
|
*
|
|
* Return: Handle to target_if psoc internal Spectral data on success, NULL on
|
|
* failure
|
|
*/
|
|
static inline
|
|
struct target_if_psoc_spectral *get_target_if_spectral_handle_from_psoc(
|
|
struct wlan_objmgr_psoc *psoc)
|
|
{
|
|
struct wlan_lmac_if_rx_ops *rx_ops;
|
|
struct target_if_psoc_spectral *psoc_spectral;
|
|
|
|
if (!psoc) {
|
|
spectral_err("psoc is null");
|
|
return NULL;
|
|
}
|
|
|
|
rx_ops = wlan_psoc_get_lmac_if_rxops(psoc);
|
|
if (!rx_ops) {
|
|
spectral_err("rx_ops is null");
|
|
return NULL;
|
|
}
|
|
|
|
psoc_spectral = (struct target_if_psoc_spectral *)
|
|
rx_ops->sptrl_rx_ops.sptrlro_get_psoc_target_handle(psoc);
|
|
|
|
return psoc_spectral;
|
|
}
|
|
|
|
/**
|
|
* target_if_vdev_get_chan_freq() - Get vdev operating channel frequency
|
|
* @vdev: Pointer to vdev
|
|
*
|
|
* Get the operating channel frequency of a given vdev
|
|
*
|
|
* Return: Operating channel frequency of a vdev in MHz
|
|
*/
|
|
static inline
|
|
int16_t target_if_vdev_get_chan_freq(struct wlan_objmgr_vdev *vdev)
|
|
{
|
|
struct wlan_objmgr_psoc *psoc = NULL;
|
|
struct wlan_lmac_if_rx_ops *rx_ops;
|
|
|
|
psoc = wlan_vdev_get_psoc(vdev);
|
|
if (!psoc) {
|
|
spectral_err("psoc is NULL");
|
|
return -EINVAL;
|
|
}
|
|
rx_ops = wlan_psoc_get_lmac_if_rxops(psoc);
|
|
if (!rx_ops) {
|
|
spectral_err("rx_ops is null");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return rx_ops->sptrl_rx_ops.sptrlro_vdev_get_chan_freq(
|
|
vdev);
|
|
}
|
|
|
|
/**
|
|
* target_if_vdev_get_chan_freq_seg2() - Get center frequency of secondary 80 of
|
|
* given vdev
|
|
* @vdev: Pointer to vdev
|
|
*
|
|
* Get the center frequency of secondary 80 of given vdev
|
|
*
|
|
* Return: center frequency of secondary 80
|
|
*/
|
|
static inline
|
|
int16_t target_if_vdev_get_chan_freq_seg2(struct wlan_objmgr_vdev *vdev)
|
|
{
|
|
struct wlan_objmgr_psoc *psoc = NULL;
|
|
struct wlan_lmac_if_rx_ops *rx_ops;
|
|
|
|
psoc = wlan_vdev_get_psoc(vdev);
|
|
if (!psoc) {
|
|
spectral_err("psoc is NULL");
|
|
return -EINVAL;
|
|
}
|
|
|
|
rx_ops = wlan_psoc_get_lmac_if_rxops(psoc);
|
|
if (!rx_ops) {
|
|
spectral_err("rx_ops is null");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return rx_ops->sptrl_rx_ops.sptrlro_vdev_get_chan_freq_seg2(vdev);
|
|
}
|
|
|
|
/**
|
|
* target_if_vdev_get_ch_width() - Get vdev operating channel bandwidth
|
|
* @vdev: Pointer to vdev
|
|
*
|
|
* Get the operating channel bandwidth of a given vdev
|
|
*
|
|
* Return: channel bandwidth enumeration corresponding to the vdev
|
|
*/
|
|
static inline
|
|
enum phy_ch_width target_if_vdev_get_ch_width(struct wlan_objmgr_vdev *vdev)
|
|
{
|
|
struct wlan_objmgr_psoc *psoc = NULL;
|
|
enum phy_ch_width ch_width;
|
|
struct wlan_lmac_if_rx_ops *rx_ops;
|
|
|
|
psoc = wlan_vdev_get_psoc(vdev);
|
|
if (!psoc) {
|
|
spectral_err("psoc is NULL");
|
|
return CH_WIDTH_INVALID;
|
|
}
|
|
|
|
rx_ops = wlan_psoc_get_lmac_if_rxops(psoc);
|
|
if (!rx_ops) {
|
|
spectral_err("rx_ops is null");
|
|
return CH_WIDTH_INVALID;
|
|
}
|
|
|
|
ch_width = rx_ops->sptrl_rx_ops.sptrlro_vdev_get_ch_width(vdev);
|
|
|
|
if (ch_width == CH_WIDTH_160MHZ) {
|
|
int16_t cfreq2;
|
|
|
|
cfreq2 = target_if_vdev_get_chan_freq_seg2(vdev);
|
|
if (cfreq2 < 0) {
|
|
spectral_err("Invalid value for cfreq2 %d", cfreq2);
|
|
return CH_WIDTH_INVALID;
|
|
}
|
|
|
|
/* Use non zero cfreq2 to identify 80p80 */
|
|
if (cfreq2)
|
|
ch_width = CH_WIDTH_80P80MHZ;
|
|
}
|
|
|
|
return ch_width;
|
|
}
|
|
|
|
/**
|
|
* target_if_vdev_get_sec20chan_freq_mhz() - Get the frequency of secondary
|
|
* 20 MHz channel for a given vdev
|
|
* @vdev: Pointer to vdev
|
|
* @sec20chan_freq: Location to return secondary 20 MHz channel
|
|
*
|
|
* Get the frequency of secondary 20 MHz channel for a given vdev
|
|
*
|
|
* Return: 0 if 20 MHz channel was returned, negative errno otherwise
|
|
*/
|
|
static inline
|
|
int target_if_vdev_get_sec20chan_freq_mhz(
|
|
struct wlan_objmgr_vdev *vdev,
|
|
uint16_t *sec20chan_freq)
|
|
{
|
|
struct wlan_objmgr_psoc *psoc = NULL;
|
|
struct wlan_lmac_if_rx_ops *rx_ops;
|
|
|
|
psoc = wlan_vdev_get_psoc(vdev);
|
|
if (!psoc) {
|
|
spectral_err("psoc is NULL");
|
|
return -EINVAL;
|
|
}
|
|
|
|
rx_ops = wlan_psoc_get_lmac_if_rxops(psoc);
|
|
if (!rx_ops) {
|
|
spectral_err("rx_ops is null");
|
|
return -EINVAL;
|
|
}
|
|
|
|
return rx_ops->sptrl_rx_ops.
|
|
sptrlro_vdev_get_sec20chan_freq_mhz(vdev, sec20chan_freq);
|
|
}
|
|
|
|
/**
|
|
* target_if_spectral_is_feature_disabled_psoc() - Check if Spectral feature is
|
|
* disabled for a given psoc
|
|
* @psoc: Pointer to psoc
|
|
*
|
|
* Return: true or false
|
|
*/
|
|
static inline
|
|
bool target_if_spectral_is_feature_disabled_psoc(struct wlan_objmgr_psoc *psoc)
|
|
{
|
|
struct wlan_lmac_if_rx_ops *rx_ops;
|
|
|
|
if (!psoc) {
|
|
spectral_err("psoc is NULL");
|
|
return true;
|
|
}
|
|
|
|
rx_ops = wlan_psoc_get_lmac_if_rxops(psoc);
|
|
if (!rx_ops) {
|
|
spectral_err("rx_ops is null");
|
|
return true;
|
|
}
|
|
|
|
if (rx_ops->sptrl_rx_ops.
|
|
sptrlro_spectral_is_feature_disabled_psoc)
|
|
return rx_ops->sptrl_rx_ops.
|
|
sptrlro_spectral_is_feature_disabled_psoc(psoc);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* target_if_spectral_is_feature_disabled_pdev() - Check if Spectral feature is
|
|
* disabled for a given pdev
|
|
* @pdev: Pointer to pdev
|
|
*
|
|
* Return: true or false
|
|
*/
|
|
static inline
|
|
bool target_if_spectral_is_feature_disabled_pdev(struct wlan_objmgr_pdev *pdev)
|
|
{
|
|
struct wlan_lmac_if_rx_ops *rx_ops;
|
|
struct wlan_objmgr_psoc *psoc;
|
|
|
|
if (!pdev) {
|
|
spectral_err("pdev is NULL");
|
|
return true;
|
|
}
|
|
|
|
psoc = wlan_pdev_get_psoc(pdev);
|
|
if (!psoc) {
|
|
spectral_err("psoc is NULL");
|
|
return true;
|
|
}
|
|
|
|
rx_ops = wlan_psoc_get_lmac_if_rxops(psoc);
|
|
if (!rx_ops) {
|
|
spectral_err("rx_ops is null");
|
|
return true;
|
|
}
|
|
|
|
if (rx_ops->sptrl_rx_ops.
|
|
sptrlro_spectral_is_feature_disabled_pdev)
|
|
return rx_ops->sptrl_rx_ops.
|
|
sptrlro_spectral_is_feature_disabled_pdev(pdev);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* target_if_spectral_set_rxchainmask() - Set Spectral Rx chainmask
|
|
* @pdev: Pointer to pdev
|
|
* @spectral_rx_chainmask: Spectral Rx chainmask
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline
|
|
void target_if_spectral_set_rxchainmask(struct wlan_objmgr_pdev *pdev,
|
|
uint8_t spectral_rx_chainmask)
|
|
{
|
|
struct wlan_objmgr_psoc *psoc = NULL;
|
|
struct target_if_spectral *spectral = NULL;
|
|
enum spectral_scan_mode smode = SPECTRAL_SCAN_MODE_NORMAL;
|
|
struct wlan_lmac_if_rx_ops *rx_ops;
|
|
|
|
psoc = wlan_pdev_get_psoc(pdev);
|
|
if (!psoc) {
|
|
spectral_err("psoc is NULL");
|
|
return;
|
|
}
|
|
|
|
rx_ops = wlan_psoc_get_lmac_if_rxops(psoc);
|
|
if (!rx_ops) {
|
|
spectral_err("rx_ops is null");
|
|
return;
|
|
}
|
|
|
|
if (smode >= SPECTRAL_SCAN_MODE_MAX) {
|
|
spectral_err("Invalid Spectral mode %u", smode);
|
|
return;
|
|
}
|
|
|
|
if (rx_ops->sptrl_rx_ops.
|
|
sptrlro_spectral_is_feature_disabled_pdev(pdev)) {
|
|
spectral_info("Spectral feature is disabled");
|
|
return;
|
|
}
|
|
|
|
spectral = get_target_if_spectral_handle_from_pdev(pdev);
|
|
if (!spectral) {
|
|
spectral_err("Spectral target if object is null");
|
|
return;
|
|
}
|
|
|
|
/* set chainmask for all the modes */
|
|
for (; smode < SPECTRAL_SCAN_MODE_MAX; smode++)
|
|
spectral->params[smode].ss_chn_mask = spectral_rx_chainmask;
|
|
}
|
|
|
|
/**
|
|
* target_if_spectral_process_phyerr() - Process Spectral PHY error
|
|
* @pdev: Pointer to pdev
|
|
* @data: PHY error data received from FW
|
|
* @datalen: Length of data
|
|
* @p_rfqual: Pointer to RF Quality information
|
|
* @p_chaninfo: Pointer to channel information
|
|
* @tsf64: TSF time instance at which the Spectral sample was received
|
|
* @acs_stats: ACS stats
|
|
*
|
|
* Process Spectral PHY error by extracting necessary information from the data
|
|
* sent by FW, and send the extracted information to application layer.
|
|
*
|
|
* Return: None
|
|
*/
|
|
static inline
|
|
void target_if_spectral_process_phyerr(
|
|
struct wlan_objmgr_pdev *pdev,
|
|
uint8_t *data, uint32_t datalen,
|
|
struct target_if_spectral_rfqual_info *p_rfqual,
|
|
struct target_if_spectral_chan_info *p_chaninfo,
|
|
uint64_t tsf64,
|
|
struct target_if_spectral_acs_stats *acs_stats)
|
|
{
|
|
struct target_if_spectral *spectral = NULL;
|
|
struct target_if_spectral_ops *p_sops = NULL;
|
|
|
|
spectral = get_target_if_spectral_handle_from_pdev(pdev);
|
|
if (!spectral) {
|
|
spectral_err("Spectral target if object is null");
|
|
return;
|
|
}
|
|
|
|
p_sops = GET_TARGET_IF_SPECTRAL_OPS(spectral);
|
|
if (!p_sops->spectral_process_phyerr) {
|
|
spectral_err("null spectral_process_phyerr");
|
|
return;
|
|
}
|
|
p_sops->spectral_process_phyerr(spectral, data, datalen,
|
|
p_rfqual, p_chaninfo,
|
|
tsf64, acs_stats);
|
|
}
|
|
|
|
static QDF_STATUS
|
|
target_if_get_spectral_msg_type(enum spectral_scan_mode smode,
|
|
enum spectral_msg_type *msg_type) {
|
|
|
|
switch (smode) {
|
|
case SPECTRAL_SCAN_MODE_NORMAL:
|
|
*msg_type = SPECTRAL_MSG_NORMAL_MODE;
|
|
break;
|
|
|
|
case SPECTRAL_SCAN_MODE_AGILE:
|
|
*msg_type = SPECTRAL_MSG_AGILE_MODE;
|
|
break;
|
|
|
|
default:
|
|
spectral_err("Invalid spectral mode");
|
|
return QDF_STATUS_E_FAILURE;
|
|
}
|
|
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
|
|
static inline bool
|
|
is_ch_width_160_or_80p80(enum phy_ch_width ch_width)
|
|
{
|
|
return (ch_width == CH_WIDTH_160MHZ || ch_width == CH_WIDTH_80P80MHZ);
|
|
}
|
|
|
|
/**
|
|
* free_samp_msg_skb() - Free SAMP message skb
|
|
* @spectral: Pointer to Spectral
|
|
* @smode: Spectral Scan mode
|
|
*
|
|
* Free SAMP message skb, if error in report processing
|
|
*
|
|
* Return: void
|
|
*/
|
|
static inline void
|
|
free_samp_msg_skb(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode)
|
|
{
|
|
enum spectral_msg_type smsg_type;
|
|
QDF_STATUS ret;
|
|
|
|
if (smode >= SPECTRAL_SCAN_MODE_MAX) {
|
|
spectral_err_rl("Invalid Spectral mode %d", smode);
|
|
return;
|
|
}
|
|
|
|
if (is_ch_width_160_or_80p80(spectral->ch_width[smode])) {
|
|
ret = target_if_get_spectral_msg_type(smode, &smsg_type);
|
|
if (QDF_IS_STATUS_ERROR(ret)) {
|
|
spectral_err("Failed to get spectral message type");
|
|
return;
|
|
}
|
|
spectral->nl_cb.free_sbuff(spectral->pdev_obj,
|
|
smsg_type);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* init_160mhz_delivery_state_machine() - Initialize 160MHz Spectral
|
|
* state machine
|
|
* @spectral: Pointer to Spectral
|
|
*
|
|
* Initialize 160MHz Spectral state machine
|
|
*
|
|
* Return: void
|
|
*/
|
|
static inline void
|
|
init_160mhz_delivery_state_machine(struct target_if_spectral *spectral)
|
|
{
|
|
uint8_t smode;
|
|
|
|
smode = 0;
|
|
for (; smode < SPECTRAL_SCAN_MODE_MAX; smode++)
|
|
spectral->state_160mhz_delivery[smode] =
|
|
SPECTRAL_REPORT_WAIT_PRIMARY80;
|
|
}
|
|
|
|
/**
|
|
* reset_160mhz_delivery_state_machine() - Reset 160MHz Spectral state machine
|
|
* @spectral: Pointer to Spectral
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Reset 160MHz Spectral state machine
|
|
*
|
|
* Return: void
|
|
*/
|
|
static inline void
|
|
reset_160mhz_delivery_state_machine(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode)
|
|
{
|
|
if (smode >= SPECTRAL_SCAN_MODE_MAX) {
|
|
spectral_err_rl("Invalid Spectral mode %d", smode);
|
|
return;
|
|
}
|
|
|
|
free_samp_msg_skb(spectral, smode);
|
|
|
|
if (is_ch_width_160_or_80p80(spectral->ch_width[smode])) {
|
|
spectral->state_160mhz_delivery[smode] =
|
|
SPECTRAL_REPORT_WAIT_PRIMARY80;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* is_secondaryseg_expected() - Is waiting for secondary 80 report
|
|
* @spectral: Pointer to Spectral
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Return true if secondary 80 report expected and mode is 160 MHz
|
|
*
|
|
* Return: true or false
|
|
*/
|
|
static inline
|
|
bool is_secondaryseg_expected(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode)
|
|
{
|
|
return
|
|
(is_ch_width_160_or_80p80(spectral->ch_width[smode]) &&
|
|
spectral->rparams.fragmentation_160[smode] &&
|
|
(spectral->state_160mhz_delivery[smode] ==
|
|
SPECTRAL_REPORT_WAIT_SECONDARY80));
|
|
}
|
|
|
|
/**
|
|
* is_primaryseg_expected() - Is waiting for primary 80 report
|
|
* @spectral: Pointer to Spectral
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Return true if mode is 160 Mhz and primary 80 report expected or
|
|
* mode is not 160 Mhz
|
|
*
|
|
* Return: true or false
|
|
*/
|
|
static inline
|
|
bool is_primaryseg_expected(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode)
|
|
{
|
|
return
|
|
(!is_ch_width_160_or_80p80(spectral->ch_width[smode]) ||
|
|
!spectral->rparams.fragmentation_160[smode] ||
|
|
(spectral->state_160mhz_delivery[smode] ==
|
|
SPECTRAL_REPORT_WAIT_PRIMARY80));
|
|
}
|
|
|
|
#ifndef OPTIMIZED_SAMP_MESSAGE
|
|
/**
|
|
* is_primaryseg_rx_inprog() - Is primary 80 report processing is in progress
|
|
* @spectral: Pointer to Spectral
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Is primary 80 report processing is in progress
|
|
*
|
|
* Return: true or false
|
|
*/
|
|
static inline
|
|
bool is_primaryseg_rx_inprog(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode)
|
|
{
|
|
return
|
|
(!is_ch_width_160_or_80p80(spectral->ch_width[smode]) ||
|
|
spectral->spectral_gen == SPECTRAL_GEN2 ||
|
|
(spectral->spectral_gen == SPECTRAL_GEN3 &&
|
|
(!spectral->rparams.fragmentation_160[smode] ||
|
|
spectral->state_160mhz_delivery[smode] ==
|
|
SPECTRAL_REPORT_RX_PRIMARY80)));
|
|
}
|
|
|
|
/**
|
|
* is_secondaryseg_rx_inprog() - Is secondary80 report processing is in progress
|
|
* @spectral: Pointer to Spectral
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Is secondary 80 report processing is in progress
|
|
*
|
|
* Return: true or false
|
|
*/
|
|
static inline
|
|
bool is_secondaryseg_rx_inprog(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode)
|
|
{
|
|
return
|
|
(is_ch_width_160_or_80p80(spectral->ch_width[smode]) &&
|
|
(spectral->spectral_gen == SPECTRAL_GEN2 ||
|
|
((spectral->spectral_gen == SPECTRAL_GEN3) &&
|
|
(!spectral->rparams.fragmentation_160[smode] ||
|
|
spectral->state_160mhz_delivery[smode] ==
|
|
SPECTRAL_REPORT_RX_SECONDARY80))));
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* clamp_fft_bin_value() - Clamp the FFT bin value between min and max
|
|
* @fft_bin_value: FFT bin value as reported by HW
|
|
* @pwr_format: FFT bin format (linear or dBm format)
|
|
*
|
|
* Each FFT bin value is represented as an 8 bit integer in SAMP message. But
|
|
* depending on the configuration, the FFT bin value reported by HW might
|
|
* exceed 8 bits. Clamp the FFT bin value between the min and max value
|
|
* which can be represented by 8 bits. For linear mode, min and max FFT bin
|
|
* value which can be represented by 8 bit is 0 and U8_MAX respectively. For
|
|
* dBm mode, min and max FFT bin value which can be represented by 8 bit is
|
|
* S8_MIN and S8_MAX respectively.
|
|
*
|
|
* Return: Clamped FFT bin value
|
|
*/
|
|
static inline uint8_t
|
|
clamp_fft_bin_value(uint16_t fft_bin_value, uint16_t pwr_format)
|
|
{
|
|
uint8_t clamped_fft_bin_value = 0;
|
|
|
|
switch (pwr_format) {
|
|
case SPECTRAL_PWR_FORMAT_LINEAR:
|
|
if (qdf_unlikely(fft_bin_value > MAX_FFTBIN_VALUE_LINEAR_MODE))
|
|
clamped_fft_bin_value = MAX_FFTBIN_VALUE_LINEAR_MODE;
|
|
else
|
|
clamped_fft_bin_value = fft_bin_value;
|
|
break;
|
|
|
|
case SPECTRAL_PWR_FORMAT_DBM:
|
|
if (qdf_unlikely((int16_t)fft_bin_value >
|
|
MAX_FFTBIN_VALUE_DBM_MODE))
|
|
clamped_fft_bin_value = MAX_FFTBIN_VALUE_DBM_MODE;
|
|
else if (qdf_unlikely((int16_t)fft_bin_value <
|
|
MIN_FFTBIN_VALUE_DBM_MODE))
|
|
clamped_fft_bin_value = MIN_FFTBIN_VALUE_DBM_MODE;
|
|
else
|
|
clamped_fft_bin_value = fft_bin_value;
|
|
break;
|
|
|
|
default:
|
|
spectral_err_rl("Invalid pwr format: %d.", pwr_format);
|
|
return 0;
|
|
}
|
|
|
|
return clamped_fft_bin_value;
|
|
}
|
|
|
|
/**
|
|
* target_if_160mhz_delivery_state_change() - State transition for 160Mhz
|
|
* Spectral
|
|
* @spectral: Pointer to spectral object
|
|
* @smode: Spectral scan mode
|
|
* @detector_id: Detector id
|
|
*
|
|
* Move the states of state machine for 160MHz spectral scan report receive
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
QDF_STATUS
|
|
target_if_160mhz_delivery_state_change(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode,
|
|
uint8_t detector_id);
|
|
|
|
/**
|
|
* target_if_sops_is_spectral_enabled() - Get whether Spectral is enabled
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Function to check whether Spectral is enabled
|
|
*
|
|
* Return: True if Spectral is enabled, false if Spectral is not enabled
|
|
*/
|
|
uint32_t target_if_sops_is_spectral_enabled(void *arg,
|
|
enum spectral_scan_mode smode);
|
|
|
|
/**
|
|
* target_if_sops_is_spectral_active() - Get whether Spectral is active
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Function to check whether Spectral is active
|
|
*
|
|
* Return: True if Spectral is active, false if Spectral is not active
|
|
*/
|
|
uint32_t target_if_sops_is_spectral_active(void *arg,
|
|
enum spectral_scan_mode smode);
|
|
|
|
/**
|
|
* target_if_sops_start_spectral_scan() - Start Spectral scan
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
* @smode: Spectral scan mode
|
|
* @err: Pointer to error code
|
|
*
|
|
* Function to start spectral scan
|
|
*
|
|
* Return: 0 on success else failure
|
|
*/
|
|
uint32_t target_if_sops_start_spectral_scan(void *arg,
|
|
enum spectral_scan_mode smode,
|
|
enum spectral_cp_error_code *err);
|
|
|
|
/**
|
|
* target_if_sops_stop_spectral_scan() - Stop Spectral scan
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Function to stop spectral scan
|
|
*
|
|
* Return: 0 in case of success, -1 on failure
|
|
*/
|
|
uint32_t target_if_sops_stop_spectral_scan(void *arg,
|
|
enum spectral_scan_mode smode);
|
|
|
|
/**
|
|
* target_if_spectral_get_extension_channel() - Get the current Extension
|
|
* channel (in MHz)
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Return: Current Extension channel (in MHz) on success, 0 on failure or if
|
|
* extension channel is not present.
|
|
*/
|
|
uint32_t
|
|
target_if_spectral_get_extension_channel(void *arg,
|
|
enum spectral_scan_mode smode);
|
|
|
|
/**
|
|
* target_if_spectral_get_current_channel() - Get the current channel (in MHz)
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Return: Current channel (in MHz) on success, 0 on failure
|
|
*/
|
|
uint32_t
|
|
target_if_spectral_get_current_channel(void *arg,
|
|
enum spectral_scan_mode smode);
|
|
|
|
|
|
/**
|
|
* target_if_spectral_reset_hw() - Reset the hardware
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
*
|
|
* This is only a placeholder since it is not currently required in the offload
|
|
* case.
|
|
*
|
|
* Return: 0
|
|
*/
|
|
uint32_t target_if_spectral_reset_hw(void *arg);
|
|
|
|
/**
|
|
* target_if_spectral_get_chain_noise_floor() - Get the Chain noise floor from
|
|
* Noisefloor history buffer
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
* @nf_buf: Pointer to buffer into which chain Noise Floor data should be copied
|
|
*
|
|
* This is only a placeholder since it is not currently required in the offload
|
|
* case.
|
|
*
|
|
* Return: 0
|
|
*/
|
|
uint32_t target_if_spectral_get_chain_noise_floor(void *arg, int16_t *nf_buf);
|
|
|
|
/**
|
|
* target_if_spectral_get_ext_noisefloor() - Get the extension channel
|
|
* noisefloor
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
*
|
|
* This is only a placeholder since it is not currently required in the offload
|
|
* case.
|
|
*
|
|
* Return: 0
|
|
*/
|
|
int8_t target_if_spectral_get_ext_noisefloor(void *arg);
|
|
|
|
/**
|
|
* target_if_spectral_get_ctl_noisefloor() - Get the control channel noisefloor
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
*
|
|
* This is only a placeholder since it is not currently required in the offload
|
|
* case.
|
|
*
|
|
* Return: 0
|
|
*/
|
|
int8_t target_if_spectral_get_ctl_noisefloor(void *arg);
|
|
|
|
/**
|
|
* target_if_spectral_get_capability() - Get whether a given Spectral hardware
|
|
* capability is available
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
* @type: Spectral hardware capability type
|
|
*
|
|
* Return: True if the capability is available, false if the capability is not
|
|
* available
|
|
*/
|
|
uint32_t target_if_spectral_get_capability(
|
|
void *arg, enum spectral_capability_type type);
|
|
|
|
/**
|
|
* target_if_spectral_set_rxfilter() - Set the RX Filter before Spectral start
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
* @rxfilter: Rx filter to be used
|
|
*
|
|
* Note: This is only a placeholder function. It is not currently required since
|
|
* FW should be taking care of setting the required filters.
|
|
*
|
|
* Return: 0
|
|
*/
|
|
uint32_t target_if_spectral_set_rxfilter(void *arg, int rxfilter);
|
|
|
|
/**
|
|
* target_if_spectral_sops_configure_params() - Configure user supplied Spectral
|
|
* parameters
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
* @params: Spectral parameters
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Return: 0 in case of success, -1 on failure
|
|
*/
|
|
uint32_t target_if_spectral_sops_configure_params(
|
|
void *arg, struct spectral_config *params,
|
|
enum spectral_scan_mode smode);
|
|
|
|
/**
|
|
* target_if_spectral_get_rxfilter() - Get the current RX Filter settings
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
*
|
|
* Note: This is only a placeholder function. It is not currently required since
|
|
* FW should be taking care of setting the required filters.
|
|
*
|
|
* Return: 0
|
|
*/
|
|
uint32_t target_if_spectral_get_rxfilter(void *arg);
|
|
|
|
/**
|
|
* target_if_pdev_spectral_deinit() - De-initialize target_if Spectral
|
|
* functionality for the given pdev
|
|
* @pdev: Pointer to pdev object
|
|
*
|
|
* Return: None
|
|
*/
|
|
void target_if_pdev_spectral_deinit(struct wlan_objmgr_pdev *pdev);
|
|
|
|
/**
|
|
* target_if_set_spectral_config() - Set spectral config
|
|
* @pdev: Pointer to pdev object
|
|
* @param: Spectral parameter id and value
|
|
* @smode: Spectral scan mode
|
|
* @err: Pointer to Spectral error code
|
|
*
|
|
* API to set spectral configurations
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS in case of success, else QDF_STATUS_E_FAILURE
|
|
*/
|
|
QDF_STATUS target_if_set_spectral_config(struct wlan_objmgr_pdev *pdev,
|
|
const struct spectral_cp_param *param,
|
|
const enum spectral_scan_mode smode,
|
|
enum spectral_cp_error_code *err);
|
|
|
|
/**
|
|
* target_if_pdev_spectral_init() - Initialize target_if Spectral
|
|
* functionality for the given pdev
|
|
* @pdev: Pointer to pdev object
|
|
*
|
|
* Return: On success, pointer to Spectral target_if internal private data, on
|
|
* failure, NULL
|
|
*/
|
|
void *target_if_pdev_spectral_init(struct wlan_objmgr_pdev *pdev);
|
|
|
|
/**
|
|
* target_if_spectral_sops_get_params() - Get user configured Spectral
|
|
* parameters
|
|
* @arg: Pointer to handle for Spectral target_if internal private data
|
|
* @params: Pointer to buffer into which Spectral parameters should be copied
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Return: 0 in case of success, -1 on failure
|
|
*/
|
|
uint32_t target_if_spectral_sops_get_params(
|
|
void *arg, struct spectral_config *params,
|
|
enum spectral_scan_mode smode);
|
|
|
|
/**
|
|
* target_if_init_spectral_capability() - Initialize Spectral capability
|
|
*
|
|
* @spectral: Pointer to Spectral target_if internal private data
|
|
* @target_type: target type
|
|
*
|
|
* This is a workaround.
|
|
*
|
|
* Return: QDF_STATUS
|
|
*/
|
|
QDF_STATUS
|
|
target_if_init_spectral_capability(struct target_if_spectral *spectral,
|
|
uint32_t target_type);
|
|
|
|
/**
|
|
* target_if_start_spectral_scan() - Start spectral scan
|
|
* @pdev: Pointer to pdev object
|
|
* @vdev_id: VDEV id
|
|
* @smode: Spectral scan mode
|
|
* @err: Spectral error code
|
|
*
|
|
* API to start spectral scan
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS in case of success, else QDF_STATUS_E_FAILURE
|
|
*/
|
|
QDF_STATUS target_if_start_spectral_scan(struct wlan_objmgr_pdev *pdev,
|
|
uint8_t vdev_id,
|
|
enum spectral_scan_mode smode,
|
|
enum spectral_cp_error_code *err);
|
|
|
|
/**
|
|
* target_if_get_spectral_config() - Get spectral configuration
|
|
* @pdev: Pointer to pdev object
|
|
* @param: Pointer to spectral_config structure in which the configuration
|
|
* should be returned
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* API to get the current spectral configuration
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS in case of success, else QDF_STATUS_E_FAILURE
|
|
*/
|
|
QDF_STATUS target_if_get_spectral_config(struct wlan_objmgr_pdev *pdev,
|
|
struct spectral_config *param,
|
|
enum spectral_scan_mode smode);
|
|
|
|
/**
|
|
* target_if_spectral_scan_enable_params() - Enable use of desired Spectral
|
|
* parameters
|
|
* @spectral: Pointer to Spectral target_if internal private data
|
|
* @spectral_params: Pointer to Spectral parameters
|
|
* @smode: Spectral scan mode
|
|
* @err: Spectral error code
|
|
*
|
|
* Enable use of desired Spectral parameters by configuring them into HW, and
|
|
* starting Spectral scan
|
|
*
|
|
* Return: 0 on success, 1 on failure
|
|
*/
|
|
int target_if_spectral_scan_enable_params(
|
|
struct target_if_spectral *spectral,
|
|
struct spectral_config *spectral_params,
|
|
enum spectral_scan_mode smode,
|
|
enum spectral_cp_error_code *err);
|
|
|
|
/**
|
|
* target_if_is_spectral_active() - Get whether Spectral is active
|
|
* @pdev: Pointer to pdev object
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Return: True if Spectral is active, false if Spectral is not active
|
|
*/
|
|
bool target_if_is_spectral_active(struct wlan_objmgr_pdev *pdev,
|
|
enum spectral_scan_mode smode);
|
|
|
|
/**
|
|
* target_if_is_spectral_enabled() - Get whether Spectral is enabled
|
|
* @pdev: Pointer to pdev object
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Return: True if Spectral is enabled, false if Spectral is not enabled
|
|
*/
|
|
bool target_if_is_spectral_enabled(struct wlan_objmgr_pdev *pdev,
|
|
enum spectral_scan_mode smode);
|
|
|
|
/**
|
|
* target_if_set_debug_level() - Set debug level for Spectral
|
|
* @pdev: Pointer to pdev object
|
|
* @debug_level: Debug level
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS in case of success, else QDF_STATUS_E_FAILURE
|
|
*
|
|
*/
|
|
QDF_STATUS target_if_set_debug_level(struct wlan_objmgr_pdev *pdev,
|
|
uint32_t debug_level);
|
|
|
|
/**
|
|
* target_if_get_debug_level() - Get debug level for Spectral
|
|
* @pdev: Pointer to pdev object
|
|
*
|
|
* Return: Current debug level
|
|
*/
|
|
uint32_t target_if_get_debug_level(struct wlan_objmgr_pdev *pdev);
|
|
|
|
|
|
/**
|
|
* target_if_get_spectral_capinfo() - Get Spectral capability information
|
|
* @pdev: Pointer to pdev object
|
|
* @scaps: Buffer into which data should be copied
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS in case of success, else QDF_STATUS_E_FAILURE
|
|
*/
|
|
QDF_STATUS target_if_get_spectral_capinfo(struct wlan_objmgr_pdev *pdev,
|
|
struct spectral_caps *scaps);
|
|
|
|
|
|
/**
|
|
* target_if_get_spectral_diagstats() - Get Spectral diagnostic statistics
|
|
* @pdev: Pointer to pdev object
|
|
* @stats: Buffer into which data should be copied
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS in case of success, else QDF_STATUS_E_FAILURE
|
|
*/
|
|
QDF_STATUS target_if_get_spectral_diagstats(struct wlan_objmgr_pdev *pdev,
|
|
struct spectral_diag_stats *stats);
|
|
|
|
QDF_STATUS
|
|
target_if_160mhz_delivery_state_change(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode,
|
|
uint8_t detector_id);
|
|
|
|
#ifdef OPTIMIZED_SAMP_MESSAGE
|
|
/**
|
|
* target_if_spectral_get_num_fft_bins() - Get number of FFT bins from FFT size
|
|
* according to the Spectral report mode.
|
|
* @fft_size: FFT length
|
|
* @report_mode: Spectral report mode
|
|
*
|
|
* Get number of FFT bins from FFT size according to the Spectral
|
|
* report mode.
|
|
*
|
|
* Return: Number of FFT bins
|
|
*/
|
|
static inline uint32_t
|
|
target_if_spectral_get_num_fft_bins(uint32_t fft_size,
|
|
enum spectral_report_mode report_mode)
|
|
{
|
|
switch (report_mode) {
|
|
case SPECTRAL_REPORT_MODE_0:
|
|
case SPECTRAL_REPORT_MODE_1:
|
|
return 0;
|
|
case SPECTRAL_REPORT_MODE_2:
|
|
return (1 << (fft_size - 1));
|
|
case SPECTRAL_REPORT_MODE_3:
|
|
return (1 << fft_size);
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
#endif /* OPTIMIZED_SAMP_MESSAGE */
|
|
|
|
#ifdef OPTIMIZED_SAMP_MESSAGE
|
|
/**
|
|
* target_if_get_detector_chwidth() - Get per-detector bandwidth
|
|
* based on channel width and fragmentation.
|
|
* @ch_width: Spectral scan channel width
|
|
* @fragmentation_160: Target type has fragmentation or not
|
|
*
|
|
* Get per-detector BW.
|
|
*
|
|
* Return: detector BW
|
|
*/
|
|
static inline
|
|
enum phy_ch_width target_if_get_detector_chwidth(enum phy_ch_width ch_width,
|
|
bool fragmentation_160)
|
|
{
|
|
return ((ch_width == CH_WIDTH_160MHZ && fragmentation_160) ?
|
|
CH_WIDTH_80MHZ : ((ch_width == CH_WIDTH_80P80MHZ) ?
|
|
CH_WIDTH_80MHZ : ch_width));
|
|
}
|
|
|
|
/**
|
|
* target_if_spectral_set_start_end_freq() - Set start and end frequencies for
|
|
* a given center frequency
|
|
* @cfreq: Center frequency for which start and end freq need to be set
|
|
* @ch_width: Spectral scan Channel width
|
|
* @fragmentation_160: Target type has fragmentation or not
|
|
* @start_end_freq: Array containing start and end frequency of detector
|
|
*
|
|
* Set the start and end frequencies for given center frequency in destination
|
|
* detector info struct
|
|
*
|
|
* Return: void
|
|
*/
|
|
static inline
|
|
void target_if_spectral_set_start_end_freq(uint32_t cfreq,
|
|
enum phy_ch_width ch_width,
|
|
bool fragmentation_160,
|
|
uint32_t *start_end_freq)
|
|
{
|
|
enum phy_ch_width det_ch_width;
|
|
|
|
det_ch_width = target_if_get_detector_chwidth(ch_width,
|
|
fragmentation_160);
|
|
|
|
start_end_freq[0] = cfreq - (wlan_reg_get_bw_value(det_ch_width) >> 1);
|
|
start_end_freq[1] = cfreq + (wlan_reg_get_bw_value(det_ch_width) >> 1);
|
|
}
|
|
#endif /* OPTIMIZED_SAMP_MESSAGE */
|
|
|
|
#ifdef DIRECT_BUF_RX_ENABLE
|
|
/**
|
|
* target_if_consume_spectral_report_gen3() - Process fft report for gen3
|
|
* @spectral: Pointer to spectral object
|
|
* @report: Pointer to spectral report
|
|
*
|
|
* Process fft report for gen3
|
|
*
|
|
* Return: Success/Failure
|
|
*/
|
|
int
|
|
target_if_consume_spectral_report_gen3(
|
|
struct target_if_spectral *spectral,
|
|
struct spectral_report *report);
|
|
#endif
|
|
|
|
/**
|
|
* target_if_spectral_fw_hang() - Crash the FW from Spectral module
|
|
* @spectral: Pointer to Spectral LMAC object
|
|
*
|
|
* Return: QDF_STATUS of operation
|
|
*/
|
|
QDF_STATUS target_if_spectral_fw_hang(struct target_if_spectral *spectral);
|
|
|
|
/**
|
|
* target_if_spectral_finite_scan_update() - Update scan count for finite scan
|
|
* and stop Spectral scan when required
|
|
* @spectral: Pointer to Spectral target_if internal private data
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* This API decrements the number of Spectral reports expected from target for
|
|
* a finite Spectral scan. When expected number of reports are received from
|
|
* target Spectral scan is stopped.
|
|
*
|
|
* Return: QDF_STATUS on success
|
|
*/
|
|
QDF_STATUS
|
|
target_if_spectral_finite_scan_update(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode);
|
|
|
|
/**
|
|
* target_if_spectral_is_finite_scan() - Check Spectral scan is finite/infinite
|
|
* @spectral: Pointer to Spectral target_if internal private data
|
|
* @smode: Spectral scan mode
|
|
* @finite_spectral_scan: location to store result
|
|
*
|
|
* API to check whether Spectral scan is finite/infinite for the give mode.
|
|
* A non zero scan count indicates that scan is finite. Scan count of 0
|
|
* indicates an infinite Spectral scan.
|
|
*
|
|
* Return: QDF_STATUS on success
|
|
*/
|
|
QDF_STATUS
|
|
target_if_spectral_is_finite_scan(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode,
|
|
bool *finite_spectral_scan);
|
|
|
|
#ifdef BIG_ENDIAN_HOST
|
|
/**
|
|
* target_if_byte_swap_spectral_headers_gen3() - Apply byte-swap on headers
|
|
* @spectral: Pointer to Spectral target_if internal private data
|
|
* @data: Pointer to the start of Spectral Scan Summary report
|
|
*
|
|
* This API is only required for Big-endian Host platforms.
|
|
* It applies 32-bit byte-swap on Spectral Scan Summary and Search FFT reports
|
|
* and copies them back to the source location.
|
|
* Padding bytes that lie between the reports won't be touched.
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS in case of success, else QDF_STATUS_E_FAILURE
|
|
*/
|
|
QDF_STATUS target_if_byte_swap_spectral_headers_gen3(
|
|
struct target_if_spectral *spectral,
|
|
void *data);
|
|
|
|
/**
|
|
* target_if_byte_swap_spectral_fft_bins_gen3() - Apply byte-swap on FFT bins
|
|
* @rparams: Pointer to Spectral report parameters
|
|
* @bin_pwr_data: Pointer to the start of FFT bins
|
|
* @num_fftbins: Number of FFT bins
|
|
*
|
|
* This API is only required for Big-endian Host platforms.
|
|
* It applies pack-mode-aware byte-swap on the FFT bins as below:
|
|
* 1. pack-mode 0 (i.e., 1 FFT bin per DWORD):
|
|
* Reads the least significant 2 bytes of each DWORD, applies 16-bit
|
|
* byte-swap on that value, and copies it back to the source location.
|
|
* 2. pack-mode 1 (i.e., 2 FFT bins per DWORD):
|
|
* Reads each FFT bin, applies 16-bit byte-swap on that value,
|
|
* and copies it back to the source location.
|
|
* 3. pack-mode 2 (4 FFT bins per DWORD):
|
|
* Nothing
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS in case of success, else QDF_STATUS_E_FAILURE
|
|
*/
|
|
QDF_STATUS target_if_byte_swap_spectral_fft_bins_gen3(
|
|
const struct spectral_report_params *rparams,
|
|
void *bin_pwr_data, size_t num_fftbins);
|
|
#endif /* BIG_ENDIAN_HOST */
|
|
|
|
#ifdef OPTIMIZED_SAMP_MESSAGE
|
|
/**
|
|
* target_if_populate_fft_bins_info() - Populate the start and end bin
|
|
* indices, on per-detector level.
|
|
* @spectral: Pointer to target_if spectral internal structure
|
|
* @smode: Spectral scan mode
|
|
*
|
|
* Populate the start and end bin indices, on per-detector level.
|
|
*
|
|
* Return: Success/Failure
|
|
*/
|
|
QDF_STATUS
|
|
target_if_populate_fft_bins_info(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode);
|
|
#else
|
|
static inline QDF_STATUS
|
|
target_if_populate_fft_bins_info(struct target_if_spectral *spectral,
|
|
enum spectral_scan_mode smode)
|
|
{
|
|
return QDF_STATUS_SUCCESS;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* spectral_is_session_info_expected_from_target() - Check if spectral scan
|
|
* session is expected from target
|
|
* @pdev: pdev pointer
|
|
* @is_session_info_expected: Pointer to caller variable
|
|
*
|
|
* Return: QDF_STATUS of operation
|
|
*/
|
|
QDF_STATUS
|
|
spectral_is_session_info_expected_from_target(struct wlan_objmgr_pdev *pdev,
|
|
bool *is_session_info_expected);
|
|
|
|
#ifdef WIN32
|
|
#pragma pack(pop, target_if_spectral)
|
|
#endif
|
|
#ifdef __ATTRIB_PACK
|
|
#undef __ATTRIB_PACK
|
|
#endif
|
|
|
|
/**
|
|
* target_if_spectral_copy_fft_bins() - Copy FFT bins from source buffer to
|
|
* destination buffer
|
|
* @spectral: Pointer to Spectral LMAC object
|
|
* @src_fft_buf: Pointer to source FFT buffer
|
|
* @dest_fft_buf: Pointer to destination FFT buffer
|
|
* @fft_bin_count: Number of FFT bins to copy
|
|
* @bytes_copied: Number of bytes copied by this API
|
|
* @pwr_format: Spectral FFT bin format (linear/dBm mode)
|
|
*
|
|
* Different targets supports different FFT bin widths. This API encapsulates
|
|
* all those details and copies 8-bit FFT value into the destination buffer.
|
|
* Also, this API takes care of handling big-endian mode.
|
|
* In essence, it does the following.
|
|
* - Read DWORDs one by one
|
|
* - Extract individual FFT bins out of it
|
|
* - Copy the FFT bin to destination buffer
|
|
*
|
|
* Return: QDF_STATUS_SUCCESS in case of success, else QDF_STATUS_E_FAILURE
|
|
*/
|
|
QDF_STATUS
|
|
target_if_spectral_copy_fft_bins(struct target_if_spectral *spectral,
|
|
const void *src_fft_buf,
|
|
void *dest_fft_buf,
|
|
uint32_t fft_bin_count,
|
|
uint32_t *bytes_copied,
|
|
uint16_t pwr_format);
|
|
#endif /* WLAN_CONV_SPECTRAL_ENABLE */
|
|
|
|
struct spectral_capabilities_event_params;
|
|
/**
|
|
* target_if_wmi_extract_spectral_caps_fixed_param() - Wrapper function to
|
|
* extract fixed params from Spectral capabilities WMI event
|
|
* @psoc: Pointer to psoc object
|
|
* @evt_buf: Event buffer
|
|
* @param: Spectral capabilities event parameters data structure to be filled
|
|
* by this API
|
|
*
|
|
* Return: QDF_STATUS of operation
|
|
*/
|
|
QDF_STATUS target_if_wmi_extract_spectral_caps_fixed_param(
|
|
struct wlan_objmgr_psoc *psoc,
|
|
uint8_t *evt_buf,
|
|
struct spectral_capabilities_event_params *param);
|
|
|
|
struct spectral_scan_bw_capabilities;
|
|
/**
|
|
* target_if_wmi_extract_spectral_scan_bw_caps() - Wrapper function to
|
|
* extract bandwidth capabilities from Spectral capabilities WMI event
|
|
* @psoc: Pointer to psoc object
|
|
* @evt_buf: Event buffer
|
|
* @bw_caps: Data structure to be filled by this API after extraction
|
|
*
|
|
* Return: QDF_STATUS of operation
|
|
*/
|
|
QDF_STATUS
|
|
target_if_wmi_extract_spectral_scan_bw_caps(
|
|
struct wlan_objmgr_psoc *psoc,
|
|
uint8_t *evt_buf,
|
|
struct spectral_scan_bw_capabilities *bw_caps);
|
|
|
|
struct spectral_fft_size_capabilities;
|
|
/**
|
|
* target_if_wmi_extract_spectral_fft_size_caps() - Wrapper function to
|
|
* extract fft size capabilities from Spectral capabilities WMI event
|
|
* @psoc: Pointer to psoc object
|
|
* @evt_buf: Event buffer
|
|
* @fft_size_caps: Data structure to be filled by this API after extraction
|
|
*
|
|
* Return: QDF_STATUS of operation
|
|
*/
|
|
QDF_STATUS
|
|
target_if_wmi_extract_spectral_fft_size_caps(
|
|
struct wlan_objmgr_psoc *psoc,
|
|
uint8_t *evt_buf,
|
|
struct spectral_fft_size_capabilities *fft_size_caps);
|
|
#endif /* _TARGET_IF_SPECTRAL_H_ */
|