drivers/net/wireless/ath/ath9k/common-spectral.c

   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 #include <linux/relay.h>
  18 #include <linux/random.h>
  19 #include "ath9k.h"
  20
  21 static s8 fix_rssi_inv_only(u8 rssi_val)
  22 {
  23         if (rssi_val == 128)
  24                 rssi_val = 0;
  25         return (s8) rssi_val;
  26 }
  27
  28 static void ath_debug_send_fft_sample(struct ath_spec_scan_priv *spec_priv,
  29                                       struct fft_sample_tlv *fft_sample_tlv)
  30 {
  31         int length;
  32         if (!spec_priv->rfs_chan_spec_scan)
  33                 return;
  34
  35         length = __be16_to_cpu(fft_sample_tlv->length) +
  36                  sizeof(*fft_sample_tlv);
  37         relay_write(spec_priv->rfs_chan_spec_scan, fft_sample_tlv, length);
  38 }
  39
  40 typedef int (ath_cmn_fft_idx_validator) (u8 *sample_end, int bytes_read);
  41
  42 static int
  43 ath_cmn_max_idx_verify_ht20_fft(u8 *sample_end, int bytes_read)
  44 {
  45         struct ath_ht20_mag_info *mag_info;
  46         u8 *sample;
  47         u16 max_magnitude;
  48         u8 max_index;
  49         u8 max_exp;
  50
  51         /* Sanity check so that we don't read outside the read
  52          * buffer
  53          */
  54         if (bytes_read < SPECTRAL_HT20_SAMPLE_LEN - 1)
  55                 return -1;
  56
  57         mag_info = (struct ath_ht20_mag_info *) (sample_end -
  58                                 sizeof(struct ath_ht20_mag_info) + 1);
  59
  60         sample = sample_end - SPECTRAL_HT20_SAMPLE_LEN + 1;
  61
  62         max_index = spectral_max_index(mag_info->all_bins,
  63                                        SPECTRAL_HT20_NUM_BINS);
  64         max_magnitude = spectral_max_magnitude(mag_info->all_bins);
  65
  66         max_exp = mag_info->max_exp & 0xf;
  67
  68         /* Don't try to read something outside the read buffer
  69          * in case of a missing byte (so bins[0] will be outside
  70          * the read buffer)
  71          */
  72         if (bytes_read < SPECTRAL_HT20_SAMPLE_LEN && max_index < 1)
  73                 return -1;
  74
  75         if (sample[max_index] != (max_magnitude >> max_exp))
  76                 return -1;
  77         else
  78                 return 0;
  79 }
  80
  81 static int
  82 ath_cmn_max_idx_verify_ht20_40_fft(u8 *sample_end, int bytes_read)
  83 {
  84         struct ath_ht20_40_mag_info *mag_info;
  85         u8 *sample;
  86         u16 lower_mag, upper_mag;
  87         u8 lower_max_index, upper_max_index;
  88         u8 max_exp;
  89         int dc_pos = SPECTRAL_HT20_40_NUM_BINS / 2;
  90
  91         /* Sanity check so that we don't read outside the read
  92          * buffer
  93          */
  94         if (bytes_read < SPECTRAL_HT20_40_SAMPLE_LEN - 1)
  95                 return -1;
  96
  97         mag_info = (struct ath_ht20_40_mag_info *) (sample_end -
  98                                 sizeof(struct ath_ht20_40_mag_info) + 1);
  99
 100         sample = sample_end - SPECTRAL_HT20_40_SAMPLE_LEN + 1;
 101
 102         lower_mag = spectral_max_magnitude(mag_info->lower_bins);
 103         lower_max_index = spectral_max_index(mag_info->lower_bins,
 104                                              SPECTRAL_HT20_40_NUM_BINS);
 105
 106         upper_mag = spectral_max_magnitude(mag_info->upper_bins);
 107         upper_max_index = spectral_max_index(mag_info->upper_bins,
 108                                              SPECTRAL_HT20_40_NUM_BINS);
 109
 110         max_exp = mag_info->max_exp & 0xf;
 111
 112         /* Don't try to read something outside the read buffer
 113          * in case of a missing byte (so bins[0] will be outside
 114          * the read buffer)
 115          */
 116         if (bytes_read < SPECTRAL_HT20_40_SAMPLE_LEN &&
 117            ((upper_max_index < 1) || (lower_max_index < 1)))
 118                 return -1;
 119
 120         /* Some time hardware messes up the index and adds
 121          * the index of the middle point (dc_pos). Try to fix it.
 122          */
 123         if ((upper_max_index - dc_pos > 0) &&
 124            (sample[upper_max_index] == (upper_mag >> max_exp)))
 125                 upper_max_index -= dc_pos;
 126
 127         if ((lower_max_index - dc_pos > 0) &&
 128            (sample[lower_max_index - dc_pos] == (lower_mag >> max_exp)))
 129                 lower_max_index -= dc_pos;
 130
 131         if ((sample[upper_max_index + dc_pos] != (upper_mag >> max_exp)) ||
 132            (sample[lower_max_index] != (lower_mag >> max_exp)))
 133                 return -1;
 134         else
 135                 return 0;
 136 }
 137
 138 typedef int (ath_cmn_fft_sample_handler) (struct ath_rx_status *rs,
 139                         struct ath_spec_scan_priv *spec_priv,
 140                         u8 *sample_buf, u64 tsf, u16 freq, int chan_type);
 141
 142 static int
 143 ath_cmn_process_ht20_fft(struct ath_rx_status *rs,
 144                         struct ath_spec_scan_priv *spec_priv,
 145                         u8 *sample_buf,
 146                         u64 tsf, u16 freq, int chan_type)
 147 {
 148         struct fft_sample_ht20 fft_sample_20;
 149         struct ath_common *common = ath9k_hw_common(spec_priv->ah);
 150         struct ath_hw *ah = spec_priv->ah;
 151         struct ath_ht20_mag_info *mag_info;
 152         struct fft_sample_tlv *tlv;
 153         int i = 0;
 154         int ret = 0;
 155         int dc_pos = SPECTRAL_HT20_NUM_BINS / 2;
 156         u16 magnitude, tmp_mag, length;
 157         u8 max_index, bitmap_w, max_exp;
 158
 159         length = sizeof(fft_sample_20) - sizeof(struct fft_sample_tlv);
 160         fft_sample_20.tlv.type = ATH_FFT_SAMPLE_HT20;
 161         fft_sample_20.tlv.length = __cpu_to_be16(length);
 162         fft_sample_20.freq = __cpu_to_be16(freq);
 163         fft_sample_20.rssi = fix_rssi_inv_only(rs->rs_rssi_ctl[0]);
 164         fft_sample_20.noise = ah->noise;
 165
 166         mag_info = (struct ath_ht20_mag_info *) (sample_buf +
 167                                         SPECTRAL_HT20_NUM_BINS);
 168
 169         magnitude = spectral_max_magnitude(mag_info->all_bins);
 170         fft_sample_20.max_magnitude = __cpu_to_be16(magnitude);
 171
 172         max_index = spectral_max_index(mag_info->all_bins,
 173                                         SPECTRAL_HT20_NUM_BINS);
 174         fft_sample_20.max_index = max_index;
 175
 176         bitmap_w = spectral_bitmap_weight(mag_info->all_bins);
 177         fft_sample_20.bitmap_weight = bitmap_w;
 178
 179         max_exp = mag_info->max_exp & 0xf;
 180         fft_sample_20.max_exp = max_exp;
 181
 182         fft_sample_20.tsf = __cpu_to_be64(tsf);
 183
 184         memcpy(fft_sample_20.data, sample_buf, SPECTRAL_HT20_NUM_BINS);
 185
 186         ath_dbg(common, SPECTRAL_SCAN, "FFT HT20 frame: max mag 0x%X,"
 187                                         "max_mag_idx %i\n",
 188                                         magnitude >> max_exp,
 189                                         max_index);
 190
 191         if (fft_sample_20.data[max_index] != (magnitude >> max_exp)) {
 192                 ath_dbg(common, SPECTRAL_SCAN, "Magnitude mismatch !\n");
 193                 ret = -1;
 194         }
 195
 196         /* DC value (value in the middle) is the blind spot of the spectral
 197          * sample and invalid, interpolate it.
 198          */
 199         fft_sample_20.data[dc_pos] = (fft_sample_20.data[dc_pos + 1] +
 200                                         fft_sample_20.data[dc_pos - 1]) / 2;
 201
 202         /* Check if the maximum magnitude is indeed maximum,
 203          * also if the maximum value was at dc_pos, calculate
 204          * a new one (since value at dc_pos is invalid).
 205          */
 206         if (max_index == dc_pos) {
 207                 tmp_mag = 0;
 208                 for (i = 0; i < dc_pos; i++) {
 209                         if (fft_sample_20.data[i] > tmp_mag) {
 210                                 tmp_mag = fft_sample_20.data[i];
 211                                 fft_sample_20.max_index = i;
 212                         }
 213                 }
 214
 215                 magnitude = tmp_mag << max_exp;
 216                 fft_sample_20.max_magnitude = __cpu_to_be16(magnitude);
 217
 218                 ath_dbg(common, SPECTRAL_SCAN,
 219                         "Calculated new lower max 0x%X at %i\n",
 220                         tmp_mag, fft_sample_20.max_index);
 221         } else
 222         for (i = 0; i < SPECTRAL_HT20_NUM_BINS; i++) {
 223                 if (fft_sample_20.data[i] == (magnitude >> max_exp))
 224                         ath_dbg(common, SPECTRAL_SCAN,
 225                                 "Got max: 0x%X at index %i\n",
 226                                 fft_sample_20.data[i], i);
 227
 228                 if (fft_sample_20.data[i] > (magnitude >> max_exp)) {
 229                         ath_dbg(common, SPECTRAL_SCAN,
 230                                 "Got bin %i greater than max: 0x%X\n",
 231                                 i, fft_sample_20.data[i]);
 232                         ret = -1;
 233                 }
 234         }
 235
 236         if (ret < 0)
 237                 return ret;
 238
 239         tlv = (struct fft_sample_tlv *)&fft_sample_20;
 240
 241         ath_debug_send_fft_sample(spec_priv, tlv);
 242
 243         return 0;
 244 }
 245
 246 static int
 247 ath_cmn_process_ht20_40_fft(struct ath_rx_status *rs,
 248                         struct ath_spec_scan_priv *spec_priv,
 249                         u8 *sample_buf,
 250                         u64 tsf, u16 freq, int chan_type)
 251 {
 252         struct fft_sample_ht20_40 fft_sample_40;
 253         struct ath_common *common = ath9k_hw_common(spec_priv->ah);
 254         struct ath_hw *ah = spec_priv->ah;
 255         struct ath9k_hw_cal_data *caldata = ah->caldata;
 256         struct ath_ht20_40_mag_info *mag_info;
 257         struct fft_sample_tlv *tlv;
 258         int dc_pos = SPECTRAL_HT20_40_NUM_BINS / 2;
 259         int i = 0;
 260         int ret = 0;
 261         s16 ext_nf;
 262         u16 lower_mag, upper_mag, tmp_mag, length;
 263         s8 lower_rssi, upper_rssi;
 264         u8 lower_max_index, upper_max_index;
 265         u8 lower_bitmap_w, upper_bitmap_w, max_exp;
 266
 267         if (caldata)
 268                 ext_nf = ath9k_hw_getchan_noise(ah, ah->curchan,
 269                                 caldata->nfCalHist[3].privNF);
 270         else
 271                 ext_nf = ATH_DEFAULT_NOISE_FLOOR;
 272
 273         length = sizeof(fft_sample_40) - sizeof(struct fft_sample_tlv);
 274         fft_sample_40.tlv.type = ATH_FFT_SAMPLE_HT20_40;
 275         fft_sample_40.tlv.length = __cpu_to_be16(length);
 276         fft_sample_40.freq = __cpu_to_be16(freq);
 277         fft_sample_40.channel_type = chan_type;
 278
 279         if (chan_type == NL80211_CHAN_HT40PLUS) {
 280                 lower_rssi = fix_rssi_inv_only(rs->rs_rssi_ctl[0]);
 281                 upper_rssi = fix_rssi_inv_only(rs->rs_rssi_ext[0]);
 282
 283                 fft_sample_40.lower_noise = ah->noise;
 284                 fft_sample_40.upper_noise = ext_nf;
 285         } else {
 286                 lower_rssi = fix_rssi_inv_only(rs->rs_rssi_ext[0]);
 287                 upper_rssi = fix_rssi_inv_only(rs->rs_rssi_ctl[0]);
 288
 289                 fft_sample_40.lower_noise = ext_nf;
 290                 fft_sample_40.upper_noise = ah->noise;
 291         }
 292
 293         fft_sample_40.lower_rssi = lower_rssi;
 294         fft_sample_40.upper_rssi = upper_rssi;
 295
 296         mag_info = (struct ath_ht20_40_mag_info *) (sample_buf +
 297                                         SPECTRAL_HT20_40_NUM_BINS);
 298
 299         lower_mag = spectral_max_magnitude(mag_info->lower_bins);
 300         fft_sample_40.lower_max_magnitude = __cpu_to_be16(lower_mag);
 301
 302         upper_mag = spectral_max_magnitude(mag_info->upper_bins);
 303         fft_sample_40.upper_max_magnitude = __cpu_to_be16(upper_mag);
 304
 305         lower_max_index = spectral_max_index(mag_info->lower_bins,
 306                                         SPECTRAL_HT20_40_NUM_BINS);
 307         fft_sample_40.lower_max_index = lower_max_index;
 308
 309         upper_max_index = spectral_max_index(mag_info->upper_bins,
 310                                         SPECTRAL_HT20_40_NUM_BINS);
 311         fft_sample_40.upper_max_index = upper_max_index;
 312
 313         lower_bitmap_w = spectral_bitmap_weight(mag_info->lower_bins);
 314         fft_sample_40.lower_bitmap_weight = lower_bitmap_w;
 315
 316         upper_bitmap_w = spectral_bitmap_weight(mag_info->upper_bins);
 317         fft_sample_40.upper_bitmap_weight = upper_bitmap_w;
 318
 319         max_exp = mag_info->max_exp & 0xf;
 320         fft_sample_40.max_exp = max_exp;
 321
 322         fft_sample_40.tsf = __cpu_to_be64(tsf);
 323
 324         memcpy(fft_sample_40.data, sample_buf, SPECTRAL_HT20_40_NUM_BINS);
 325
 326         ath_dbg(common, SPECTRAL_SCAN, "FFT HT20/40 frame: lower mag 0x%X,"
 327                                         "lower_mag_idx %i, upper mag 0x%X,"
 328                                         "upper_mag_idx %i\n",
 329                                         lower_mag >> max_exp,
 330                                         lower_max_index,
 331                                         upper_mag >> max_exp,
 332                                         upper_max_index);
 333
 334         /* Some time hardware messes up the index and adds
 335          * the index of the middle point (dc_pos). Try to fix it.
 336          */
 337         if ((upper_max_index - dc_pos > 0) &&
 338            (fft_sample_40.data[upper_max_index] == (upper_mag >> max_exp))) {
 339                 upper_max_index -= dc_pos;
 340                 fft_sample_40.upper_max_index = upper_max_index;
 341         }
 342
 343         if ((lower_max_index - dc_pos > 0) &&
 344            (fft_sample_40.data[lower_max_index - dc_pos] ==
 345            (lower_mag >> max_exp))) {
 346                 lower_max_index -= dc_pos;
 347                 fft_sample_40.lower_max_index = lower_max_index;
 348         }
 349
 350         /* Check if we got the expected magnitude values at
 351          * the expected bins
 352          */
 353         if ((fft_sample_40.data[upper_max_index + dc_pos]
 354             != (upper_mag >> max_exp)) ||
 355            (fft_sample_40.data[lower_max_index]
 356             != (lower_mag >> max_exp))) {
 357                 ath_dbg(common, SPECTRAL_SCAN, "Magnitude mismatch !\n");
 358                 ret = -1;
 359         }
 360
 361         /* DC value (value in the middle) is the blind spot of the spectral
 362          * sample and invalid, interpolate it.
 363          */
 364         fft_sample_40.data[dc_pos] = (fft_sample_40.data[dc_pos + 1] +
 365                                         fft_sample_40.data[dc_pos - 1]) / 2;
 366
 367         /* Check if the maximum magnitudes are indeed maximum,
 368          * also if the maximum value was at dc_pos, calculate
 369          * a new one (since value at dc_pos is invalid).
 370          */
 371         if (lower_max_index == dc_pos) {
 372                 tmp_mag = 0;
 373                 for (i = 0; i < dc_pos; i++) {
 374                         if (fft_sample_40.data[i] > tmp_mag) {
 375                                 tmp_mag = fft_sample_40.data[i];
 376                                 fft_sample_40.lower_max_index = i;
 377                         }
 378                 }
 379
 380                 lower_mag = tmp_mag << max_exp;
 381                 fft_sample_40.lower_max_magnitude = __cpu_to_be16(lower_mag);
 382
 383                 ath_dbg(common, SPECTRAL_SCAN,
 384                         "Calculated new lower max 0x%X at %i\n",
 385                         tmp_mag, fft_sample_40.lower_max_index);
 386         } else
 387         for (i = 0; i < dc_pos; i++) {
 388                 if (fft_sample_40.data[i] == (lower_mag >> max_exp))
 389                         ath_dbg(common, SPECTRAL_SCAN,
 390                                 "Got lower mag: 0x%X at index %i\n",
 391                                 fft_sample_40.data[i], i);
 392
 393                 if (fft_sample_40.data[i] > (lower_mag >> max_exp)) {
 394                         ath_dbg(common, SPECTRAL_SCAN,
 395                                 "Got lower bin %i higher than max: 0x%X\n",
 396                                 i, fft_sample_40.data[i]);
 397                         ret = -1;
 398                 }
 399         }
 400
 401         if (upper_max_index == dc_pos) {
 402                 tmp_mag = 0;
 403                 for (i = dc_pos; i < SPECTRAL_HT20_40_NUM_BINS; i++) {
 404                         if (fft_sample_40.data[i] > tmp_mag) {
 405                                 tmp_mag = fft_sample_40.data[i];
 406                                 fft_sample_40.upper_max_index = i;
 407                         }
 408                 }
 409                 upper_mag = tmp_mag << max_exp;
 410                 fft_sample_40.upper_max_magnitude = __cpu_to_be16(upper_mag);
 411
 412                 ath_dbg(common, SPECTRAL_SCAN,
 413                         "Calculated new upper max 0x%X at %i\n",
 414                         tmp_mag, i);
 415         } else
 416         for (i = dc_pos; i < SPECTRAL_HT20_40_NUM_BINS; i++) {
 417                 if (fft_sample_40.data[i] == (upper_mag >> max_exp))
 418                         ath_dbg(common, SPECTRAL_SCAN,
 419                                 "Got upper mag: 0x%X at index %i\n",
 420                                 fft_sample_40.data[i], i);
 421
 422                 if (fft_sample_40.data[i] > (upper_mag >> max_exp)) {
 423                         ath_dbg(common, SPECTRAL_SCAN,
 424                                 "Got upper bin %i higher than max: 0x%X\n",
 425                                 i, fft_sample_40.data[i]);
 426
 427                         ret = -1;
 428                 }
 429         }
 430
 431         if (ret < 0)
 432                 return ret;
 433
 434         tlv = (struct fft_sample_tlv *)&fft_sample_40;
 435
 436         ath_debug_send_fft_sample(spec_priv, tlv);
 437
 438         return 0;
 439 }
 440
 441 static inline void
 442 ath_cmn_copy_fft_frame(u8 *in, u8 *out, int sample_len, int sample_bytes)
 443 {
 444         switch (sample_bytes - sample_len) {
 445         case -1:
 446                 /* First byte missing */
 447                 memcpy(&out[1], in,
 448                        sample_len - 1);
 449                 break;
 450         case 0:
 451                 /* Length correct, nothing to do. */
 452                 memcpy(out, in, sample_len);
 453                 break;
 454         case 1:
 455                 /* MAC added 2 extra bytes AND first byte
 456                  * is missing.
 457                  */
 458                 memcpy(&out[1], in, 30);
 459                 out[31] = in[31];
 460                 memcpy(&out[32], &in[33],
 461                        sample_len - 32);
 462                 break;
 463         case 2:
 464                 /* MAC added 2 extra bytes at bin 30 and 32,
 465                  * remove them.
 466                  */
 467                 memcpy(out, in, 30);
 468                 out[30] = in[31];
 469                 memcpy(&out[31], &in[33],
 470                        sample_len - 31);
 471                 break;
 472         default:
 473                 break;
 474         }
 475 }
 476
 477 static int
 478 ath_cmn_is_fft_buf_full(struct ath_spec_scan_priv *spec_priv)
 479 {
 480         int i = 0;
 481         int ret = 0;
 482         struct rchan *rc = spec_priv->rfs_chan_spec_scan;
 483
 484         for_each_online_cpu(i)
 485                 ret += relay_buf_full(rc->buf[i]);
 486
 487         i = num_online_cpus();
 488
 489         if (ret == i)
 490                 return 1;
 491         else
 492                 return 0;
 493 }
 494
 495 /* returns 1 if this was a spectral frame, even if not handled. */
 496 int ath_cmn_process_fft(struct ath_spec_scan_priv *spec_priv, struct ieee80211_hdr *hdr,
 497                     struct ath_rx_status *rs, u64 tsf)
 498 {
 499         u8 sample_buf[SPECTRAL_SAMPLE_MAX_LEN] = {0};
 500         struct ath_hw *ah = spec_priv->ah;
 501         struct ath_common *common = ath9k_hw_common(spec_priv->ah);
 502         u8 num_bins, *vdata = (u8 *)hdr;
 503         struct ath_radar_info *radar_info;
 504         int len = rs->rs_datalen;
 505         int i;
 506         int got_slen = 0;
 507         u8  *sample_start;
 508         int sample_bytes = 0;
 509         int ret = 0;
 510         u16 fft_len, sample_len, freq = ah->curchan->chan->center_freq;
 511         enum nl80211_channel_type chan_type;
 512         ath_cmn_fft_idx_validator *fft_idx_validator;
 513         ath_cmn_fft_sample_handler *fft_handler;
 514
 515         /* AR9280 and before report via ATH9K_PHYERR_RADAR, AR93xx and newer
 516          * via ATH9K_PHYERR_SPECTRAL. Haven't seen ATH9K_PHYERR_FALSE_RADAR_EXT
 517          * yet, but this is supposed to be possible as well.
 518          */
 519         if (rs->rs_phyerr != ATH9K_PHYERR_RADAR &&
 520             rs->rs_phyerr != ATH9K_PHYERR_FALSE_RADAR_EXT &&
 521             rs->rs_phyerr != ATH9K_PHYERR_SPECTRAL)
 522                 return 0;
 523
 524         /* check if spectral scan bit is set. This does not have to be checked
 525          * if received through a SPECTRAL phy error, but shouldn't hurt.
 526          */
 527         radar_info = ((struct ath_radar_info *)&vdata[len]) - 1;
 528         if (!(radar_info->pulse_bw_info & SPECTRAL_SCAN_BITMASK))
 529                 return 0;
 530
 531         /* Output buffers are full, no need to process anything
 532          * since there is no space to put the result anyway
 533          */
 534         ret = ath_cmn_is_fft_buf_full(spec_priv);
 535         if (ret == 1) {
 536                 ath_dbg(common, SPECTRAL_SCAN, "FFT report ignored, no space "
 537                                                 "left on output buffers\n");
 538                 return 1;
 539         }
 540
 541         chan_type = cfg80211_get_chandef_type(&common->hw->conf.chandef);
 542         if ((chan_type == NL80211_CHAN_HT40MINUS) ||
 543             (chan_type == NL80211_CHAN_HT40PLUS)) {
 544                 fft_len = SPECTRAL_HT20_40_TOTAL_DATA_LEN;
 545                 sample_len = SPECTRAL_HT20_40_SAMPLE_LEN;
 546                 num_bins = SPECTRAL_HT20_40_NUM_BINS;
 547                 fft_idx_validator = &ath_cmn_max_idx_verify_ht20_40_fft;
 548                 fft_handler = &ath_cmn_process_ht20_40_fft;
 549         } else {
 550                 fft_len = SPECTRAL_HT20_TOTAL_DATA_LEN;
 551                 sample_len = SPECTRAL_HT20_SAMPLE_LEN;
 552                 num_bins = SPECTRAL_HT20_NUM_BINS;
 553                 fft_idx_validator = ath_cmn_max_idx_verify_ht20_fft;
 554                 fft_handler = &ath_cmn_process_ht20_fft;
 555         }
 556
 557         ath_dbg(common, SPECTRAL_SCAN, "Got radar dump bw_info: 0x%X,"
 558                                         "len: %i fft_len: %i\n",
 559                                         radar_info->pulse_bw_info,
 560                                         len,
 561                                         fft_len);
 562         sample_start = vdata;
 563         for (i = 0; i < len - 2; i++) {
 564                 sample_bytes++;
 565
 566                 /* Only a single sample received, no need to look
 567                  * for the sample's end, do the correction based
 568                  * on the packet's length instead. Note that hw
 569                  * will always put the radar_info structure on
 570                  * the end.
 571                  */
 572                 if (len <= fft_len + 2) {
 573                         sample_bytes = len - sizeof(struct ath_radar_info);
 574                         got_slen = 1;
 575                 }
 576
 577                 /* Search for the end of the FFT frame between
 578                  * sample_len - 1 and sample_len + 2. exp_max is 3
 579                  * bits long and it's the only value on the last
 580                  * byte of the frame so since it'll be smaller than
 581                  * the next byte (the first bin of the next sample)
 582                  * 90% of the time, we can use it as a separator.
 583                  */
 584                 if (vdata[i] <= 0x7 && sample_bytes >= sample_len - 1) {
 585
 586                         /* Got a frame length within boundaries, there are
 587                          * four scenarios here:
 588                          *
 589                          * a) sample_len -> We got the correct length
 590                          * b) sample_len + 2 -> 2 bytes added around bin[31]
 591                          * c) sample_len - 1 -> The first byte is missing
 592                          * d) sample_len + 1 -> b + c at the same time
 593                          *
 594                          * When MAC adds 2 extra bytes, bin[31] and bin[32]
 595                          * have the same value, so we can use that for further
 596                          * verification in cases b and d.
 597                          */
 598
 599                         /* Did we go too far ? If so we couldn't determine
 600                          * this sample's boundaries, discard any further
 601                          * data
 602                          */
 603                         if ((sample_bytes > sample_len + 2) ||
 604                            ((sample_bytes > sample_len) &&
 605                            (sample_start[31] != sample_start[32])))
 606                                 break;
 607
 608                         /* See if we got a valid frame by checking the
 609                          * consistency of mag_info fields. This is to
 610                          * prevent from "fixing" a correct frame.
 611                          * Failure is non-fatal, later frames may
 612                          * be valid.
 613                          */
 614                         if (!fft_idx_validator(&vdata[i], i)) {
 615                                 ath_dbg(common, SPECTRAL_SCAN,
 616                                         "Found valid fft frame at %i\n", i);
 617                                 got_slen = 1;
 618                         }
 619
 620                         /* We expect 1 - 2 more bytes */
 621                         else if ((sample_start[31] == sample_start[32]) &&
 622                                 (sample_bytes >= sample_len) &&
 623                                 (sample_bytes < sample_len + 2) &&
 624                                 (vdata[i + 1] <= 0x7))
 625                                 continue;
 626
 627                         /* Try to distinguish cases a and c */
 628                         else if ((sample_bytes == sample_len - 1) &&
 629                                 (vdata[i + 1] <= 0x7))
 630                                 continue;
 631
 632                         got_slen = 1;
 633                 }
 634
 635                 if (got_slen) {
 636                         ath_dbg(common, SPECTRAL_SCAN, "FFT frame len: %i\n",
 637                                 sample_bytes);
 638
 639                         /* Only try to fix a frame if it's the only one
 640                          * on the report, else just skip it.
 641                          */
 642                         if (sample_bytes != sample_len && len <= fft_len + 2) {
 643                                 ath_cmn_copy_fft_frame(sample_start,
 644                                                        sample_buf, sample_len,
 645                                                        sample_bytes);
 646
 647                                 fft_handler(rs, spec_priv, sample_buf,
 648                                             tsf, freq, chan_type);
 649
 650                                 memset(sample_buf, 0, SPECTRAL_SAMPLE_MAX_LEN);
 651
 652                                 /* Mix the received bins to the /dev/random
 653                                  * pool
 654                                  */
 655                                 add_device_randomness(sample_buf, num_bins);
 656                         }
 657
 658                         /* Process a normal frame */
 659                         if (sample_bytes == sample_len) {
 660                                 ret = fft_handler(rs, spec_priv, sample_start,
 661                                                   tsf, freq, chan_type);
 662
 663                                 /* Mix the received bins to the /dev/random
 664                                  * pool
 665                                  */
 666                                 add_device_randomness(sample_start, num_bins);
 667                         }
 668
 669                         /* Short report processed, break out of the
 670                          * loop.
 671                          */
 672                         if (len <= fft_len + 2)
 673                                 break;
 674
 675                         sample_start = &vdata[i + 1];
 676
 677                         /* -1 to grab sample_len -1, -2 since
 678                          * they 'll get increased by one. In case
 679                          * of failure try to recover by going byte
 680                          * by byte instead.
 681                          */
 682                         if (ret == 0) {
 683                                 i += num_bins - 2;
 684                                 sample_bytes = num_bins - 2;
 685                         }
 686                         got_slen = 0;
 687                 }
 688         }
 689
 690         i -= num_bins - 2;
 691         if (len - i != sizeof(struct ath_radar_info))
 692                 ath_dbg(common, SPECTRAL_SCAN, "FFT report truncated"
 693                                                 "(bytes left: %i)\n",
 694                                                 len - i);
 695         return 1;
 696 }
 697 EXPORT_SYMBOL(ath_cmn_process_fft);
 698
 699 /*********************/
 700 /* spectral_scan_ctl */
 701 /*********************/
 702
 703 static ssize_t read_file_spec_scan_ctl(struct file *file, char __user *user_buf,
 704                                        size_t count, loff_t *ppos)
 705 {
 706         struct ath_spec_scan_priv *spec_priv = file->private_data;
 707         char *mode = "";
 708         unsigned int len;
 709
 710         switch (spec_priv->spectral_mode) {
 711         case SPECTRAL_DISABLED:
 712                 mode = "disable";
 713                 break;
 714         case SPECTRAL_BACKGROUND:
 715                 mode = "background";
 716                 break;
 717         case SPECTRAL_CHANSCAN:
 718                 mode = "chanscan";
 719                 break;
 720         case SPECTRAL_MANUAL:
 721                 mode = "manual";
 722                 break;
 723         }
 724         len = strlen(mode);
 725         return simple_read_from_buffer(user_buf, count, ppos, mode, len);
 726 }
 727
 728 void ath9k_cmn_spectral_scan_trigger(struct ath_common *common,
 729                                  struct ath_spec_scan_priv *spec_priv)
 730 {
 731         struct ath_hw *ah = spec_priv->ah;
 732         u32 rxfilter;
 733
 734         if (config_enabled(CONFIG_ATH9K_TX99))
 735                 return;
 736
 737         if (!ath9k_hw_ops(ah)->spectral_scan_trigger) {
 738                 ath_err(common, "spectrum analyzer not implemented on this hardware\n");
 739                 return;
 740         }
 741
 742         ath_ps_ops(common)->wakeup(common);
 743         rxfilter = ath9k_hw_getrxfilter(ah);
 744         ath9k_hw_setrxfilter(ah, rxfilter |
 745                                  ATH9K_RX_FILTER_PHYRADAR |
 746                                  ATH9K_RX_FILTER_PHYERR);
 747
 748         /* TODO: usually this should not be neccesary, but for some reason
 749          * (or in some mode?) the trigger must be called after the
 750          * configuration, otherwise the register will have its values reset
 751          * (on my ar9220 to value 0x01002310)
 752          */
 753         ath9k_cmn_spectral_scan_config(common, spec_priv, spec_priv->spectral_mode);
 754         ath9k_hw_ops(ah)->spectral_scan_trigger(ah);
 755         ath_ps_ops(common)->restore(common);
 756 }
 757 EXPORT_SYMBOL(ath9k_cmn_spectral_scan_trigger);
 758
 759 int ath9k_cmn_spectral_scan_config(struct ath_common *common,
 760                                struct ath_spec_scan_priv *spec_priv,
 761                                enum spectral_mode spectral_mode)
 762 {
 763         struct ath_hw *ah = spec_priv->ah;
 764
 765         if (!ath9k_hw_ops(ah)->spectral_scan_trigger) {
 766                 ath_err(common, "spectrum analyzer not implemented on this hardware\n");
 767                 return -1;
 768         }
 769
 770         switch (spectral_mode) {
 771         case SPECTRAL_DISABLED:
 772                 spec_priv->spec_config.enabled = 0;
 773                 break;
 774         case SPECTRAL_BACKGROUND:
 775                 /* send endless samples.
 776                  * TODO: is this really useful for "background"?
 777                  */
 778                 spec_priv->spec_config.endless = 1;
 779                 spec_priv->spec_config.enabled = 1;
 780                 break;
 781         case SPECTRAL_CHANSCAN:
 782         case SPECTRAL_MANUAL:
 783                 spec_priv->spec_config.endless = 0;
 784                 spec_priv->spec_config.enabled = 1;
 785                 break;
 786         default:
 787                 return -1;
 788         }
 789
 790         ath_ps_ops(common)->wakeup(common);
 791         ath9k_hw_ops(ah)->spectral_scan_config(ah, &spec_priv->spec_config);
 792         ath_ps_ops(common)->restore(common);
 793
 794         spec_priv->spectral_mode = spectral_mode;
 795
 796         return 0;
 797 }
 798 EXPORT_SYMBOL(ath9k_cmn_spectral_scan_config);
 799
 800 static ssize_t write_file_spec_scan_ctl(struct file *file,
 801                                         const char __user *user_buf,
 802                                         size_t count, loff_t *ppos)
 803 {
 804         struct ath_spec_scan_priv *spec_priv = file->private_data;
 805         struct ath_common *common = ath9k_hw_common(spec_priv->ah);
 806         char buf[32];
 807         ssize_t len;
 808
 809         if (config_enabled(CONFIG_ATH9K_TX99))
 810                 return -EOPNOTSUPP;
 811
 812         len = min(count, sizeof(buf) - 1);
 813         if (copy_from_user(buf, user_buf, len))
 814                 return -EFAULT;
 815
 816         buf[len] = '\0';
 817
 818         if (strncmp("trigger", buf, 7) == 0) {
 819                 ath9k_cmn_spectral_scan_trigger(common, spec_priv);
 820         } else if (strncmp("background", buf, 10) == 0) {
 821                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_BACKGROUND);
 822                 ath_dbg(common, CONFIG, "spectral scan: background mode enabled\n");
 823         } else if (strncmp("chanscan", buf, 8) == 0) {
 824                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_CHANSCAN);
 825                 ath_dbg(common, CONFIG, "spectral scan: channel scan mode enabled\n");
 826         } else if (strncmp("manual", buf, 6) == 0) {
 827                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_MANUAL);
 828                 ath_dbg(common, CONFIG, "spectral scan: manual mode enabled\n");
 829         } else if (strncmp("disable", buf, 7) == 0) {
 830                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_DISABLED);
 831                 ath_dbg(common, CONFIG, "spectral scan: disabled\n");
 832         } else {
 833                 return -EINVAL;
 834         }
 835
 836         return count;
 837 }
 838
 839 static const struct file_operations fops_spec_scan_ctl = {
 840         .read = read_file_spec_scan_ctl,
 841         .write = write_file_spec_scan_ctl,
 842         .open = simple_open,
 843         .owner = THIS_MODULE,
 844         .llseek = default_llseek,
 845 };
 846
 847 /*************************/
 848 /* spectral_short_repeat */
 849 /*************************/
 850
 851 static ssize_t read_file_spectral_short_repeat(struct file *file,
 852                                                char __user *user_buf,
 853                                                size_t count, loff_t *ppos)
 854 {
 855         struct ath_spec_scan_priv *spec_priv = file->private_data;
 856         char buf[32];
 857         unsigned int len;
 858
 859         len = sprintf(buf, "%d\n", spec_priv->spec_config.short_repeat);
 860         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 861 }
 862
 863 static ssize_t write_file_spectral_short_repeat(struct file *file,
 864                                                 const char __user *user_buf,
 865                                                 size_t count, loff_t *ppos)
 866 {
 867         struct ath_spec_scan_priv *spec_priv = file->private_data;
 868         unsigned long val;
 869         char buf[32];
 870         ssize_t len;
 871
 872         len = min(count, sizeof(buf) - 1);
 873         if (copy_from_user(buf, user_buf, len))
 874                 return -EFAULT;
 875
 876         buf[len] = '\0';
 877         if (kstrtoul(buf, 0, &val))
 878                 return -EINVAL;
 879
 880         if (val > 1)
 881                 return -EINVAL;
 882
 883         spec_priv->spec_config.short_repeat = val;
 884         return count;
 885 }
 886
 887 static const struct file_operations fops_spectral_short_repeat = {
 888         .read = read_file_spectral_short_repeat,
 889         .write = write_file_spectral_short_repeat,
 890         .open = simple_open,
 891         .owner = THIS_MODULE,
 892         .llseek = default_llseek,
 893 };
 894
 895 /******************/
 896 /* spectral_count */
 897 /******************/
 898
 899 static ssize_t read_file_spectral_count(struct file *file,
 900                                         char __user *user_buf,
 901                                         size_t count, loff_t *ppos)
 902 {
 903         struct ath_spec_scan_priv *spec_priv = file->private_data;
 904         char buf[32];
 905         unsigned int len;
 906
 907         len = sprintf(buf, "%d\n", spec_priv->spec_config.count);
 908         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 909 }
 910
 911 static ssize_t write_file_spectral_count(struct file *file,
 912                                          const char __user *user_buf,
 913                                          size_t count, loff_t *ppos)
 914 {
 915         struct ath_spec_scan_priv *spec_priv = file->private_data;
 916         unsigned long val;
 917         char buf[32];
 918         ssize_t len;
 919
 920         len = min(count, sizeof(buf) - 1);
 921         if (copy_from_user(buf, user_buf, len))
 922                 return -EFAULT;
 923
 924         buf[len] = '\0';
 925         if (kstrtoul(buf, 0, &val))
 926                 return -EINVAL;
 927
 928         if (val > 255)
 929                 return -EINVAL;
 930
 931         spec_priv->spec_config.count = val;
 932         return count;
 933 }
 934
 935 static const struct file_operations fops_spectral_count = {
 936         .read = read_file_spectral_count,
 937         .write = write_file_spectral_count,
 938         .open = simple_open,
 939         .owner = THIS_MODULE,
 940         .llseek = default_llseek,
 941 };
 942
 943 /*******************/
 944 /* spectral_period */
 945 /*******************/
 946
 947 static ssize_t read_file_spectral_period(struct file *file,
 948                                          char __user *user_buf,
 949                                          size_t count, loff_t *ppos)
 950 {
 951         struct ath_spec_scan_priv *spec_priv = file->private_data;
 952         char buf[32];
 953         unsigned int len;
 954
 955         len = sprintf(buf, "%d\n", spec_priv->spec_config.period);
 956         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 957 }
 958
 959 static ssize_t write_file_spectral_period(struct file *file,
 960                                           const char __user *user_buf,
 961                                           size_t count, loff_t *ppos)
 962 {
 963         struct ath_spec_scan_priv *spec_priv = file->private_data;
 964         unsigned long val;
 965         char buf[32];
 966         ssize_t len;
 967
 968         len = min(count, sizeof(buf) - 1);
 969         if (copy_from_user(buf, user_buf, len))
 970                 return -EFAULT;
 971
 972         buf[len] = '\0';
 973         if (kstrtoul(buf, 0, &val))
 974                 return -EINVAL;
 975
 976         if (val > 255)
 977                 return -EINVAL;
 978
 979         spec_priv->spec_config.period = val;
 980         return count;
 981 }
 982
 983 static const struct file_operations fops_spectral_period = {
 984         .read = read_file_spectral_period,
 985         .write = write_file_spectral_period,
 986         .open = simple_open,
 987         .owner = THIS_MODULE,
 988         .llseek = default_llseek,
 989 };
 990
 991 /***********************/
 992 /* spectral_fft_period */
 993 /***********************/
 994
 995 static ssize_t read_file_spectral_fft_period(struct file *file,
 996                                              char __user *user_buf,
 997                                              size_t count, loff_t *ppos)
 998 {
 999         struct ath_spec_scan_priv *spec_priv = file->private_data;
1000         char buf[32];
1001         unsigned int len;
1002
1003         len = sprintf(buf, "%d\n", spec_priv->spec_config.fft_period);
1004         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1005 }
1006
1007 static ssize_t write_file_spectral_fft_period(struct file *file,
1008                                               const char __user *user_buf,
1009                                               size_t count, loff_t *ppos)
1010 {
1011         struct ath_spec_scan_priv *spec_priv = file->private_data;
1012         unsigned long val;
1013         char buf[32];
1014         ssize_t len;
1015
1016         len = min(count, sizeof(buf) - 1);
1017         if (copy_from_user(buf, user_buf, len))
1018                 return -EFAULT;
1019
1020         buf[len] = '\0';
1021         if (kstrtoul(buf, 0, &val))
1022                 return -EINVAL;
1023
1024         if (val > 15)
1025                 return -EINVAL;
1026
1027         spec_priv->spec_config.fft_period = val;
1028         return count;
1029 }
1030
1031 static const struct file_operations fops_spectral_fft_period = {
1032         .read = read_file_spectral_fft_period,
1033         .write = write_file_spectral_fft_period,
1034         .open = simple_open,
1035         .owner = THIS_MODULE,
1036         .llseek = default_llseek,
1037 };
1038
1039 /*******************/
1040 /* Relay interface */
1041 /*******************/
1042
1043 static struct dentry *create_buf_file_handler(const char *filename,
1044                                               struct dentry *parent,
1045                                               umode_t mode,
1046                                               struct rchan_buf *buf,
1047                                               int *is_global)
1048 {
1049         struct dentry *buf_file;
1050
1051         buf_file = debugfs_create_file(filename, mode, parent, buf,
1052                                        &relay_file_operations);
1053         *is_global = 1;
1054         return buf_file;
1055 }
1056
1057 static int remove_buf_file_handler(struct dentry *dentry)
1058 {
1059         debugfs_remove(dentry);
1060
1061         return 0;
1062 }
1063
1064 static struct rchan_callbacks rfs_spec_scan_cb = {
1065         .create_buf_file = create_buf_file_handler,
1066         .remove_buf_file = remove_buf_file_handler,
1067 };
1068
1069 /*********************/
1070 /* Debug Init/Deinit */
1071 /*********************/
1072
1073 void ath9k_cmn_spectral_deinit_debug(struct ath_spec_scan_priv *spec_priv)
1074 {
1075         if (config_enabled(CONFIG_ATH9K_DEBUGFS)) {
1076                 relay_close(spec_priv->rfs_chan_spec_scan);
1077                 spec_priv->rfs_chan_spec_scan = NULL;
1078         }
1079 }
1080 EXPORT_SYMBOL(ath9k_cmn_spectral_deinit_debug);
1081
1082 void ath9k_cmn_spectral_init_debug(struct ath_spec_scan_priv *spec_priv,
1083                                    struct dentry *debugfs_phy)
1084 {
1085         spec_priv->rfs_chan_spec_scan = relay_open("spectral_scan",
1086                                             debugfs_phy,
1087                                             1024, 256, &rfs_spec_scan_cb,
1088                                             NULL);
1089         debugfs_create_file("spectral_scan_ctl",
1090                             S_IRUSR | S_IWUSR,
1091                             debugfs_phy, spec_priv,
1092                             &fops_spec_scan_ctl);
1093         debugfs_create_file("spectral_short_repeat",
1094                             S_IRUSR | S_IWUSR,
1095                             debugfs_phy, spec_priv,
1096                             &fops_spectral_short_repeat);
1097         debugfs_create_file("spectral_count",
1098                             S_IRUSR | S_IWUSR,
1099                             debugfs_phy, spec_priv,
1100                             &fops_spectral_count);
1101         debugfs_create_file("spectral_period",
1102                             S_IRUSR | S_IWUSR,
1103                             debugfs_phy, spec_priv,
1104                             &fops_spectral_period);
1105         debugfs_create_file("spectral_fft_period",
1106                             S_IRUSR | S_IWUSR,
1107                             debugfs_phy, spec_priv,
1108                             &fops_spectral_fft_period);
1109 }
1110 EXPORT_SYMBOL(ath9k_cmn_spectral_init_debug);