LCOV - code coverage report
Current view: top level - drivers/net/wireless/ath/ath9k - common-spectral.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 0 22 0.0 %
Date: 2022-03-28 13:20:08 Functions: 0 0 -
Branches: 0 46 0.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright (c) 2013 Qualcomm Atheros, Inc.
       3                 :            :  *
       4                 :            :  * Permission to use, copy, modify, and/or distribute this software for any
       5                 :            :  * purpose with or without fee is hereby granted, provided that the above
       6                 :            :  * copyright notice and this permission notice appear in all copies.
       7                 :            :  *
       8                 :            :  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
       9                 :            :  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
      10                 :            :  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
      11                 :            :  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
      12                 :            :  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
      13                 :            :  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
      14                 :            :  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
      15                 :            :  */
      16                 :            : 
      17                 :            : #ifndef SPECTRAL_H
      18                 :            : #define SPECTRAL_H
      19                 :            : 
      20                 :            : #include "../spectral_common.h"
      21                 :            : 
      22                 :            : /* enum spectral_mode:
      23                 :            :  *
      24                 :            :  * @SPECTRAL_DISABLED: spectral mode is disabled
      25                 :            :  * @SPECTRAL_BACKGROUND: hardware sends samples when it is not busy with
      26                 :            :  *      something else.
      27                 :            :  * @SPECTRAL_MANUAL: spectral scan is enabled, triggering for samples
      28                 :            :  *      is performed manually.
      29                 :            :  * @SPECTRAL_CHANSCAN: Like manual, but also triggered when changing channels
      30                 :            :  *      during a channel scan.
      31                 :            :  */
      32                 :            : enum spectral_mode {
      33                 :            :         SPECTRAL_DISABLED = 0,
      34                 :            :         SPECTRAL_BACKGROUND,
      35                 :            :         SPECTRAL_MANUAL,
      36                 :            :         SPECTRAL_CHANSCAN,
      37                 :            : };
      38                 :            : 
      39                 :            : #define SPECTRAL_SCAN_BITMASK           0x10
      40                 :            : /* Radar info packet format, used for DFS and spectral formats. */
      41                 :            : struct ath_radar_info {
      42                 :            :         u8 pulse_length_pri;
      43                 :            :         u8 pulse_length_ext;
      44                 :            :         u8 pulse_bw_info;
      45                 :            : } __packed;
      46                 :            : 
      47                 :            : /* The HT20 spectral data has 4 bytes of additional information at it's end.
      48                 :            :  *
      49                 :            :  * [7:0]: all bins {max_magnitude[1:0], bitmap_weight[5:0]}
      50                 :            :  * [7:0]: all bins  max_magnitude[9:2]
      51                 :            :  * [7:0]: all bins {max_index[5:0], max_magnitude[11:10]}
      52                 :            :  * [3:0]: max_exp (shift amount to size max bin to 8-bit unsigned)
      53                 :            :  */
      54                 :            : struct ath_ht20_mag_info {
      55                 :            :         u8 all_bins[3];
      56                 :            :         u8 max_exp;
      57                 :            : } __packed;
      58                 :            : 
      59                 :            : /* WARNING: don't actually use this struct! MAC may vary the amount of
      60                 :            :  * data by -1/+2. This struct is for reference only.
      61                 :            :  */
      62                 :            : struct ath_ht20_fft_packet {
      63                 :            :         u8 data[SPECTRAL_HT20_NUM_BINS];
      64                 :            :         struct ath_ht20_mag_info mag_info;
      65                 :            :         struct ath_radar_info radar_info;
      66                 :            : } __packed;
      67                 :            : 
      68                 :            : #define SPECTRAL_HT20_TOTAL_DATA_LEN    (sizeof(struct ath_ht20_fft_packet))
      69                 :            : #define SPECTRAL_HT20_SAMPLE_LEN        (sizeof(struct ath_ht20_mag_info) +\
      70                 :            :                                         SPECTRAL_HT20_NUM_BINS)
      71                 :            : 
      72                 :            : /* Dynamic 20/40 mode:
      73                 :            :  *
      74                 :            :  * [7:0]: lower bins {max_magnitude[1:0], bitmap_weight[5:0]}
      75                 :            :  * [7:0]: lower bins  max_magnitude[9:2]
      76                 :            :  * [7:0]: lower bins {max_index[5:0], max_magnitude[11:10]}
      77                 :            :  * [7:0]: upper bins {max_magnitude[1:0], bitmap_weight[5:0]}
      78                 :            :  * [7:0]: upper bins  max_magnitude[9:2]
      79                 :            :  * [7:0]: upper bins {max_index[5:0], max_magnitude[11:10]}
      80                 :            :  * [3:0]: max_exp (shift amount to size max bin to 8-bit unsigned)
      81                 :            :  */
      82                 :            : struct ath_ht20_40_mag_info {
      83                 :            :         u8 lower_bins[3];
      84                 :            :         u8 upper_bins[3];
      85                 :            :         u8 max_exp;
      86                 :            : } __packed;
      87                 :            : 
      88                 :            : /* WARNING: don't actually use this struct! MAC may vary the amount of
      89                 :            :  * data. This struct is for reference only.
      90                 :            :  */
      91                 :            : struct ath_ht20_40_fft_packet {
      92                 :            :         u8 data[SPECTRAL_HT20_40_NUM_BINS];
      93                 :            :         struct ath_ht20_40_mag_info mag_info;
      94                 :            :         struct ath_radar_info radar_info;
      95                 :            : } __packed;
      96                 :            : 
      97                 :            : struct ath_spec_scan_priv {
      98                 :            :         struct ath_hw *ah;
      99                 :            :         /* relay(fs) channel for spectral scan */
     100                 :            :         struct rchan *rfs_chan_spec_scan;
     101                 :            :         enum spectral_mode spectral_mode;
     102                 :            :         struct ath_spec_scan spec_config;
     103                 :            : };
     104                 :            : 
     105                 :            : #define SPECTRAL_HT20_40_TOTAL_DATA_LEN (sizeof(struct ath_ht20_40_fft_packet))
     106                 :            : #define SPECTRAL_HT20_40_SAMPLE_LEN     (sizeof(struct ath_ht20_40_mag_info) +\
     107                 :            :                                         SPECTRAL_HT20_40_NUM_BINS)
     108                 :            : 
     109                 :            : #define SPECTRAL_SAMPLE_MAX_LEN         SPECTRAL_HT20_40_SAMPLE_LEN
     110                 :            : 
     111                 :            : /* grabs the max magnitude from the all/upper/lower bins */
     112                 :          0 : static inline u16 spectral_max_magnitude(u8 *bins)
     113                 :            : {
     114                 :          0 :         return (bins[0] & 0xc0) >> 6 |
     115                 :          0 :                (bins[1] & 0xff) << 2 |
     116   [ #  #  #  #  :          0 :                (bins[2] & 0x03) << 10;
          #  #  #  #  #  
                      # ]
     117                 :            : }
     118                 :            : 
     119                 :            : /* return the max magnitude from the all/upper/lower bins */
     120                 :          0 : static inline u8 spectral_max_index(u8 *bins, int num_bins)
     121                 :            : {
     122                 :          0 :         s8 m = (bins[2] & 0xfc) >> 2;
     123                 :          0 :         u8 zero_idx = num_bins / 2;
     124                 :            : 
     125                 :            :         /* It's a 5 bit signed int, remove its sign and use one's
     126                 :            :          * complement interpretation to add the sign back to the 8
     127                 :            :          * bit int
     128                 :            :          */
     129                 :          0 :         if (m & 0x20) {
     130                 :          0 :                 m &= ~0x20;
     131                 :          0 :                 m |= 0xe0;
     132                 :            :         }
     133                 :            : 
     134                 :            :         /* Bring the zero point to the beginning
     135                 :            :          * instead of the middle so that we can use
     136                 :            :          * it for array lookup and that we don't deal
     137                 :            :          * with negative values later
     138                 :            :          */
     139                 :          0 :         m += zero_idx;
     140                 :            : 
     141                 :            :         /* Sanity check to make sure index is within bounds */
     142   [ #  #  #  #  :          0 :         if (m < 0 || m > num_bins - 1)
             #  #  #  # ]
     143                 :          0 :                 m = 0;
     144                 :            : 
     145   [ #  #  #  # ]:          0 :         return m;
     146                 :            : }
     147                 :            : 
     148                 :          0 : static inline u8 spectral_max_index_ht40(u8 *bins)
     149                 :            : {
     150                 :          0 :         u8 idx;
     151                 :            : 
     152   [ #  #  #  #  :          0 :         idx = spectral_max_index(bins, SPECTRAL_HT20_40_NUM_BINS);
             #  #  #  # ]
     153                 :            : 
     154                 :            :         /* positive values and zero are starting at the beginning
     155                 :            :          * of the data field.
     156                 :            :          */
     157   [ #  #  #  #  :          0 :         return idx % (SPECTRAL_HT20_40_NUM_BINS / 2);
             #  #  #  # ]
     158                 :            : }
     159                 :            : 
     160                 :          0 : static inline u8 spectral_max_index_ht20(u8 *bins)
     161                 :            : {
     162   [ #  #  #  # ]:          0 :         return spectral_max_index(bins, SPECTRAL_HT20_NUM_BINS);
     163                 :            : }
     164                 :            : 
     165                 :            : /* return the bitmap weight from the all/upper/lower bins */
     166                 :          0 : static inline u8 spectral_bitmap_weight(u8 *bins)
     167                 :            : {
     168   [ #  #  #  # ]:          0 :         return bins[0] & 0x3f;
     169                 :            : }
     170                 :            : 
     171                 :            : #ifdef CONFIG_ATH9K_COMMON_SPECTRAL
     172                 :            : void ath9k_cmn_spectral_init_debug(struct ath_spec_scan_priv *spec_priv, struct dentry *debugfs_phy);
     173                 :            : void ath9k_cmn_spectral_deinit_debug(struct ath_spec_scan_priv *spec_priv);
     174                 :            : 
     175                 :            : void ath9k_cmn_spectral_scan_trigger(struct ath_common *common,
     176                 :            :                                  struct ath_spec_scan_priv *spec_priv);
     177                 :            : int ath9k_cmn_spectral_scan_config(struct ath_common *common,
     178                 :            :                                struct ath_spec_scan_priv *spec_priv,
     179                 :            :                                enum spectral_mode spectral_mode);
     180                 :            : int ath_cmn_process_fft(struct ath_spec_scan_priv *spec_priv, struct ieee80211_hdr *hdr,
     181                 :            :                     struct ath_rx_status *rs, u64 tsf);
     182                 :            : #else
     183                 :            : static inline void ath9k_cmn_spectral_init_debug(struct ath_spec_scan_priv *spec_priv,
     184                 :            :                                                  struct dentry *debugfs_phy)
     185                 :            : {
     186                 :            : }
     187                 :            : 
     188                 :            : static inline void ath9k_cmn_spectral_deinit_debug(struct ath_spec_scan_priv *spec_priv)
     189                 :            : {
     190                 :            : }
     191                 :            : 
     192                 :            : static inline void ath9k_cmn_spectral_scan_trigger(struct ath_common *common,
     193                 :            :                                                    struct ath_spec_scan_priv *spec_priv)
     194                 :            : {
     195                 :            : }
     196                 :            : 
     197                 :            : static inline int ath_cmn_process_fft(struct ath_spec_scan_priv *spec_priv,
     198                 :            :                                       struct ieee80211_hdr *hdr,
     199                 :            :                                       struct ath_rx_status *rs, u64 tsf)
     200                 :            : {
     201                 :            :         return 0;
     202                 :            : }
     203                 :            : #endif /* CONFIG_ATH9K_COMMON_SPECTRAL */
     204                 :            : 
     205                 :            : #endif /* SPECTRAL_H */

Generated by: LCOV version 1.14