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_buf *buf;
 483         struct rchan *rc = spec_priv->rfs_chan_spec_scan;
 484
 485         for_each_possible_cpu(i) {
 486                 if ((buf = *per_cpu_ptr(rc->buf, i))) {
 487                         ret += relay_buf_full(buf);
 488                 }
 489         }
 490
 491         if (ret)
 492                 return 1;
 493         else
 494                 return 0;
 495 }
 496
 497 /* returns 1 if this was a spectral frame, even if not handled. */
 498 int ath_cmn_process_fft(struct ath_spec_scan_priv *spec_priv, struct ieee80211_hdr *hdr,
 499                     struct ath_rx_status *rs, u64 tsf)
 500 {
 501         u8 sample_buf[SPECTRAL_SAMPLE_MAX_LEN] = {0};
 502         struct ath_hw *ah = spec_priv->ah;
 503         struct ath_common *common = ath9k_hw_common(spec_priv->ah);
 504         u8 num_bins, *vdata = (u8 *)hdr;
 505         struct ath_radar_info *radar_info;
 506         int len = rs->rs_datalen;
 507         int i;
 508         int got_slen = 0;
 509         u8  *sample_start;
 510         int sample_bytes = 0;
 511         int ret = 0;
 512         u16 fft_len, sample_len, freq = ah->curchan->chan->center_freq;
 513         enum nl80211_channel_type chan_type;
 514         ath_cmn_fft_idx_validator *fft_idx_validator;
 515         ath_cmn_fft_sample_handler *fft_handler;
 516
 517         /* AR9280 and before report via ATH9K_PHYERR_RADAR, AR93xx and newer
 518          * via ATH9K_PHYERR_SPECTRAL. Haven't seen ATH9K_PHYERR_FALSE_RADAR_EXT
 519          * yet, but this is supposed to be possible as well.
 520          */
 521         if (rs->rs_phyerr != ATH9K_PHYERR_RADAR &&
 522             rs->rs_phyerr != ATH9K_PHYERR_FALSE_RADAR_EXT &&
 523             rs->rs_phyerr != ATH9K_PHYERR_SPECTRAL)
 524                 return 0;
 525
 526         /* check if spectral scan bit is set. This does not have to be checked
 527          * if received through a SPECTRAL phy error, but shouldn't hurt.
 528          */
 529         radar_info = ((struct ath_radar_info *)&vdata[len]) - 1;
 530         if (!(radar_info->pulse_bw_info & SPECTRAL_SCAN_BITMASK))
 531                 return 0;
 532
 533         if (!spec_priv->rfs_chan_spec_scan)
 534                 return 1;
 535
 536         /* Output buffers are full, no need to process anything
 537          * since there is no space to put the result anyway
 538          */
 539         ret = ath_cmn_is_fft_buf_full(spec_priv);
 540         if (ret == 1) {
 541                 ath_dbg(common, SPECTRAL_SCAN, "FFT report ignored, no space "
 542                                                 "left on output buffers\n");
 543                 return 1;
 544         }
 545
 546         chan_type = cfg80211_get_chandef_type(&common->hw->conf.chandef);
 547         if ((chan_type == NL80211_CHAN_HT40MINUS) ||
 548             (chan_type == NL80211_CHAN_HT40PLUS)) {
 549                 fft_len = SPECTRAL_HT20_40_TOTAL_DATA_LEN;
 550                 sample_len = SPECTRAL_HT20_40_SAMPLE_LEN;
 551                 num_bins = SPECTRAL_HT20_40_NUM_BINS;
 552                 fft_idx_validator = &ath_cmn_max_idx_verify_ht20_40_fft;
 553                 fft_handler = &ath_cmn_process_ht20_40_fft;
 554         } else {
 555                 fft_len = SPECTRAL_HT20_TOTAL_DATA_LEN;
 556                 sample_len = SPECTRAL_HT20_SAMPLE_LEN;
 557                 num_bins = SPECTRAL_HT20_NUM_BINS;
 558                 fft_idx_validator = ath_cmn_max_idx_verify_ht20_fft;
 559                 fft_handler = &ath_cmn_process_ht20_fft;
 560         }
 561
 562         ath_dbg(common, SPECTRAL_SCAN, "Got radar dump bw_info: 0x%X,"
 563                                         "len: %i fft_len: %i\n",
 564                                         radar_info->pulse_bw_info,
 565                                         len,
 566                                         fft_len);
 567         sample_start = vdata;
 568         for (i = 0; i < len - 2; i++) {
 569                 sample_bytes++;
 570
 571                 /* Only a single sample received, no need to look
 572                  * for the sample's end, do the correction based
 573                  * on the packet's length instead. Note that hw
 574                  * will always put the radar_info structure on
 575                  * the end.
 576                  */
 577                 if (len <= fft_len + 2) {
 578                         sample_bytes = len - sizeof(struct ath_radar_info);
 579                         got_slen = 1;
 580                 }
 581
 582                 /* Search for the end of the FFT frame between
 583                  * sample_len - 1 and sample_len + 2. exp_max is 3
 584                  * bits long and it's the only value on the last
 585                  * byte of the frame so since it'll be smaller than
 586                  * the next byte (the first bin of the next sample)
 587                  * 90% of the time, we can use it as a separator.
 588                  */
 589                 if (vdata[i] <= 0x7 && sample_bytes >= sample_len - 1) {
 590
 591                         /* Got a frame length within boundaries, there are
 592                          * four scenarios here:
 593                          *
 594                          * a) sample_len -> We got the correct length
 595                          * b) sample_len + 2 -> 2 bytes added around bin[31]
 596                          * c) sample_len - 1 -> The first byte is missing
 597                          * d) sample_len + 1 -> b + c at the same time
 598                          *
 599                          * When MAC adds 2 extra bytes, bin[31] and bin[32]
 600                          * have the same value, so we can use that for further
 601                          * verification in cases b and d.
 602                          */
 603
 604                         /* Did we go too far ? If so we couldn't determine
 605                          * this sample's boundaries, discard any further
 606                          * data
 607                          */
 608                         if ((sample_bytes > sample_len + 2) ||
 609                            ((sample_bytes > sample_len) &&
 610                            (sample_start[31] != sample_start[32])))
 611                                 break;
 612
 613                         /* See if we got a valid frame by checking the
 614                          * consistency of mag_info fields. This is to
 615                          * prevent from "fixing" a correct frame.
 616                          * Failure is non-fatal, later frames may
 617                          * be valid.
 618                          */
 619                         if (!fft_idx_validator(&vdata[i], i)) {
 620                                 ath_dbg(common, SPECTRAL_SCAN,
 621                                         "Found valid fft frame at %i\n", i);
 622                                 got_slen = 1;
 623                         }
 624
 625                         /* We expect 1 - 2 more bytes */
 626                         else if ((sample_start[31] == sample_start[32]) &&
 627                                 (sample_bytes >= sample_len) &&
 628                                 (sample_bytes < sample_len + 2) &&
 629                                 (vdata[i + 1] <= 0x7))
 630                                 continue;
 631
 632                         /* Try to distinguish cases a and c */
 633                         else if ((sample_bytes == sample_len - 1) &&
 634                                 (vdata[i + 1] <= 0x7))
 635                                 continue;
 636
 637                         got_slen = 1;
 638                 }
 639
 640                 if (got_slen) {
 641                         ath_dbg(common, SPECTRAL_SCAN, "FFT frame len: %i\n",
 642                                 sample_bytes);
 643
 644                         /* Only try to fix a frame if it's the only one
 645                          * on the report, else just skip it.
 646                          */
 647                         if (sample_bytes != sample_len && len <= fft_len + 2) {
 648                                 ath_cmn_copy_fft_frame(sample_start,
 649                                                        sample_buf, sample_len,
 650                                                        sample_bytes);
 651
 652                                 fft_handler(rs, spec_priv, sample_buf,
 653                                             tsf, freq, chan_type);
 654
 655                                 memset(sample_buf, 0, SPECTRAL_SAMPLE_MAX_LEN);
 656
 657                                 /* Mix the received bins to the /dev/random
 658                                  * pool
 659                                  */
 660                                 add_device_randomness(sample_buf, num_bins);
 661                         }
 662
 663                         /* Process a normal frame */
 664                         if (sample_bytes == sample_len) {
 665                                 ret = fft_handler(rs, spec_priv, sample_start,
 666                                                   tsf, freq, chan_type);
 667
 668                                 /* Mix the received bins to the /dev/random
 669                                  * pool
 670                                  */
 671                                 add_device_randomness(sample_start, num_bins);
 672                         }
 673
 674                         /* Short report processed, break out of the
 675                          * loop.
 676                          */
 677                         if (len <= fft_len + 2)
 678                                 break;
 679
 680                         sample_start = &vdata[i + 1];
 681
 682                         /* -1 to grab sample_len -1, -2 since
 683                          * they 'll get increased by one. In case
 684                          * of failure try to recover by going byte
 685                          * by byte instead.
 686                          */
 687                         if (ret == 0) {
 688                                 i += num_bins - 2;
 689                                 sample_bytes = num_bins - 2;
 690                         }
 691                         got_slen = 0;
 692                 }
 693         }
 694
 695         i -= num_bins - 2;
 696         if (len - i != sizeof(struct ath_radar_info))
 697                 ath_dbg(common, SPECTRAL_SCAN, "FFT report truncated"
 698                                                 "(bytes left: %i)\n",
 699                                                 len - i);
 700         return 1;
 701 }
 702 EXPORT_SYMBOL(ath_cmn_process_fft);
 703
 704 /*********************/
 705 /* spectral_scan_ctl */
 706 /*********************/
 707
 708 static ssize_t read_file_spec_scan_ctl(struct file *file, char __user *user_buf,
 709                                        size_t count, loff_t *ppos)
 710 {
 711         struct ath_spec_scan_priv *spec_priv = file->private_data;
 712         char *mode = "";
 713         unsigned int len;
 714
 715         switch (spec_priv->spectral_mode) {
 716         case SPECTRAL_DISABLED:
 717                 mode = "disable";
 718                 break;
 719         case SPECTRAL_BACKGROUND:
 720                 mode = "background";
 721                 break;
 722         case SPECTRAL_CHANSCAN:
 723                 mode = "chanscan";
 724                 break;
 725         case SPECTRAL_MANUAL:
 726                 mode = "manual";
 727                 break;
 728         }
 729         len = strlen(mode);
 730         return simple_read_from_buffer(user_buf, count, ppos, mode, len);
 731 }
 732
 733 void ath9k_cmn_spectral_scan_trigger(struct ath_common *common,
 734                                  struct ath_spec_scan_priv *spec_priv)
 735 {
 736         struct ath_hw *ah = spec_priv->ah;
 737         u32 rxfilter;
 738
 739         if (IS_ENABLED(CONFIG_ATH9K_TX99))
 740                 return;
 741
 742         if (!ath9k_hw_ops(ah)->spectral_scan_trigger) {
 743                 ath_err(common, "spectrum analyzer not implemented on this hardware\n");
 744                 return;
 745         }
 746
 747         if (!spec_priv->spec_config.enabled)
 748                 return;
 749
 750         ath_ps_ops(common)->wakeup(common);
 751         rxfilter = ath9k_hw_getrxfilter(ah);
 752         ath9k_hw_setrxfilter(ah, rxfilter |
 753                                  ATH9K_RX_FILTER_PHYRADAR |
 754                                  ATH9K_RX_FILTER_PHYERR);
 755
 756         /* TODO: usually this should not be neccesary, but for some reason
 757          * (or in some mode?) the trigger must be called after the
 758          * configuration, otherwise the register will have its values reset
 759          * (on my ar9220 to value 0x01002310)
 760          */
 761         ath9k_cmn_spectral_scan_config(common, spec_priv, spec_priv->spectral_mode);
 762         ath9k_hw_ops(ah)->spectral_scan_trigger(ah);
 763         ath_ps_ops(common)->restore(common);
 764 }
 765 EXPORT_SYMBOL(ath9k_cmn_spectral_scan_trigger);
 766
 767 int ath9k_cmn_spectral_scan_config(struct ath_common *common,
 768                                struct ath_spec_scan_priv *spec_priv,
 769                                enum spectral_mode spectral_mode)
 770 {
 771         struct ath_hw *ah = spec_priv->ah;
 772
 773         if (!ath9k_hw_ops(ah)->spectral_scan_trigger) {
 774                 ath_err(common, "spectrum analyzer not implemented on this hardware\n");
 775                 return -1;
 776         }
 777
 778         switch (spectral_mode) {
 779         case SPECTRAL_DISABLED:
 780                 spec_priv->spec_config.enabled = 0;
 781                 break;
 782         case SPECTRAL_BACKGROUND:
 783                 /* send endless samples.
 784                  * TODO: is this really useful for "background"?
 785                  */
 786                 spec_priv->spec_config.endless = 1;
 787                 spec_priv->spec_config.enabled = 1;
 788                 break;
 789         case SPECTRAL_CHANSCAN:
 790         case SPECTRAL_MANUAL:
 791                 spec_priv->spec_config.endless = 0;
 792                 spec_priv->spec_config.enabled = 1;
 793                 break;
 794         default:
 795                 return -1;
 796         }
 797
 798         ath_ps_ops(common)->wakeup(common);
 799         ath9k_hw_ops(ah)->spectral_scan_config(ah, &spec_priv->spec_config);
 800         ath_ps_ops(common)->restore(common);
 801
 802         spec_priv->spectral_mode = spectral_mode;
 803
 804         return 0;
 805 }
 806 EXPORT_SYMBOL(ath9k_cmn_spectral_scan_config);
 807
 808 static ssize_t write_file_spec_scan_ctl(struct file *file,
 809                                         const char __user *user_buf,
 810                                         size_t count, loff_t *ppos)
 811 {
 812         struct ath_spec_scan_priv *spec_priv = file->private_data;
 813         struct ath_common *common = ath9k_hw_common(spec_priv->ah);
 814         char buf[32];
 815         ssize_t len;
 816
 817         if (IS_ENABLED(CONFIG_ATH9K_TX99))
 818                 return -EOPNOTSUPP;
 819
 820         len = min(count, sizeof(buf) - 1);
 821         if (copy_from_user(buf, user_buf, len))
 822                 return -EFAULT;
 823
 824         buf[len] = '\0';
 825
 826         if (strncmp("trigger", buf, 7) == 0) {
 827                 ath9k_cmn_spectral_scan_trigger(common, spec_priv);
 828         } else if (strncmp("background", buf, 10) == 0) {
 829                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_BACKGROUND);
 830                 ath_dbg(common, CONFIG, "spectral scan: background mode enabled\n");
 831         } else if (strncmp("chanscan", buf, 8) == 0) {
 832                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_CHANSCAN);
 833                 ath_dbg(common, CONFIG, "spectral scan: channel scan mode enabled\n");
 834         } else if (strncmp("manual", buf, 6) == 0) {
 835                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_MANUAL);
 836                 ath_dbg(common, CONFIG, "spectral scan: manual mode enabled\n");
 837         } else if (strncmp("disable", buf, 7) == 0) {
 838                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_DISABLED);
 839                 ath_dbg(common, CONFIG, "spectral scan: disabled\n");
 840         } else {
 841                 return -EINVAL;
 842         }
 843
 844         return count;
 845 }
 846
 847 static const struct file_operations fops_spec_scan_ctl = {
 848         .read = read_file_spec_scan_ctl,
 849         .write = write_file_spec_scan_ctl,
 850         .open = simple_open,
 851         .owner = THIS_MODULE,
 852         .llseek = default_llseek,
 853 };
 854
 855 /*************************/
 856 /* spectral_short_repeat */
 857 /*************************/
 858
 859 static ssize_t read_file_spectral_short_repeat(struct file *file,
 860                                                char __user *user_buf,
 861                                                size_t count, loff_t *ppos)
 862 {
 863         struct ath_spec_scan_priv *spec_priv = file->private_data;
 864         char buf[32];
 865         unsigned int len;
 866
 867         len = sprintf(buf, "%d\n", spec_priv->spec_config.short_repeat);
 868         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 869 }
 870
 871 static ssize_t write_file_spectral_short_repeat(struct file *file,
 872                                                 const char __user *user_buf,
 873                                                 size_t count, loff_t *ppos)
 874 {
 875         struct ath_spec_scan_priv *spec_priv = file->private_data;
 876         unsigned long val;
 877         char buf[32];
 878         ssize_t len;
 879
 880         len = min(count, sizeof(buf) - 1);
 881         if (copy_from_user(buf, user_buf, len))
 882                 return -EFAULT;
 883
 884         buf[len] = '\0';
 885         if (kstrtoul(buf, 0, &val))
 886                 return -EINVAL;
 887
 888         if (val > 1)
 889                 return -EINVAL;
 890
 891         spec_priv->spec_config.short_repeat = val;
 892         return count;
 893 }
 894
 895 static const struct file_operations fops_spectral_short_repeat = {
 896         .read = read_file_spectral_short_repeat,
 897         .write = write_file_spectral_short_repeat,
 898         .open = simple_open,
 899         .owner = THIS_MODULE,
 900         .llseek = default_llseek,
 901 };
 902
 903 /******************/
 904 /* spectral_count */
 905 /******************/
 906
 907 static ssize_t read_file_spectral_count(struct file *file,
 908                                         char __user *user_buf,
 909                                         size_t count, loff_t *ppos)
 910 {
 911         struct ath_spec_scan_priv *spec_priv = file->private_data;
 912         char buf[32];
 913         unsigned int len;
 914
 915         len = sprintf(buf, "%d\n", spec_priv->spec_config.count);
 916         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 917 }
 918
 919 static ssize_t write_file_spectral_count(struct file *file,
 920                                          const char __user *user_buf,
 921                                          size_t count, loff_t *ppos)
 922 {
 923         struct ath_spec_scan_priv *spec_priv = file->private_data;
 924         unsigned long val;
 925         char buf[32];
 926         ssize_t len;
 927
 928         len = min(count, sizeof(buf) - 1);
 929         if (copy_from_user(buf, user_buf, len))
 930                 return -EFAULT;
 931
 932         buf[len] = '\0';
 933         if (kstrtoul(buf, 0, &val))
 934                 return -EINVAL;
 935
 936         if (val > 255)
 937                 return -EINVAL;
 938
 939         spec_priv->spec_config.count = val;
 940         return count;
 941 }
 942
 943 static const struct file_operations fops_spectral_count = {
 944         .read = read_file_spectral_count,
 945         .write = write_file_spectral_count,
 946         .open = simple_open,
 947         .owner = THIS_MODULE,
 948         .llseek = default_llseek,
 949 };
 950
 951 /*******************/
 952 /* spectral_period */
 953 /*******************/
 954
 955 static ssize_t read_file_spectral_period(struct file *file,
 956                                          char __user *user_buf,
 957                                          size_t count, loff_t *ppos)
 958 {
 959         struct ath_spec_scan_priv *spec_priv = file->private_data;
 960         char buf[32];
 961         unsigned int len;
 962
 963         len = sprintf(buf, "%d\n", spec_priv->spec_config.period);
 964         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 965 }
 966
 967 static ssize_t write_file_spectral_period(struct file *file,
 968                                           const char __user *user_buf,
 969                                           size_t count, loff_t *ppos)
 970 {
 971         struct ath_spec_scan_priv *spec_priv = file->private_data;
 972         unsigned long val;
 973         char buf[32];
 974         ssize_t len;
 975
 976         len = min(count, sizeof(buf) - 1);
 977         if (copy_from_user(buf, user_buf, len))
 978                 return -EFAULT;
 979
 980         buf[len] = '\0';
 981         if (kstrtoul(buf, 0, &val))
 982                 return -EINVAL;
 983
 984         if (val > 255)
 985                 return -EINVAL;
 986
 987         spec_priv->spec_config.period = val;
 988         return count;
 989 }
 990
 991 static const struct file_operations fops_spectral_period = {
 992         .read = read_file_spectral_period,
 993         .write = write_file_spectral_period,
 994         .open = simple_open,
 995         .owner = THIS_MODULE,
 996         .llseek = default_llseek,
 997 };
 998
 999 /***********************/
1000 /* spectral_fft_period */
1001 /***********************/
1002
1003 static ssize_t read_file_spectral_fft_period(struct file *file,
1004                                              char __user *user_buf,
1005                                              size_t count, loff_t *ppos)
1006 {
1007         struct ath_spec_scan_priv *spec_priv = file->private_data;
1008         char buf[32];
1009         unsigned int len;
1010
1011         len = sprintf(buf, "%d\n", spec_priv->spec_config.fft_period);
1012         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1013 }
1014
1015 static ssize_t write_file_spectral_fft_period(struct file *file,
1016                                               const char __user *user_buf,
1017                                               size_t count, loff_t *ppos)
1018 {
1019         struct ath_spec_scan_priv *spec_priv = file->private_data;
1020         unsigned long val;
1021         char buf[32];
1022         ssize_t len;
1023
1024         len = min(count, sizeof(buf) - 1);
1025         if (copy_from_user(buf, user_buf, len))
1026                 return -EFAULT;
1027
1028         buf[len] = '\0';
1029         if (kstrtoul(buf, 0, &val))
1030                 return -EINVAL;
1031
1032         if (val > 15)
1033                 return -EINVAL;
1034
1035         spec_priv->spec_config.fft_period = val;
1036         return count;
1037 }
1038
1039 static const struct file_operations fops_spectral_fft_period = {
1040         .read = read_file_spectral_fft_period,
1041         .write = write_file_spectral_fft_period,
1042         .open = simple_open,
1043         .owner = THIS_MODULE,
1044         .llseek = default_llseek,
1045 };
1046
1047 /*******************/
1048 /* Relay interface */
1049 /*******************/
1050
1051 static struct dentry *create_buf_file_handler(const char *filename,
1052                                               struct dentry *parent,
1053                                               umode_t mode,
1054                                               struct rchan_buf *buf,
1055                                               int *is_global)
1056 {
1057         struct dentry *buf_file;
1058
1059         buf_file = debugfs_create_file(filename, mode, parent, buf,
1060                                        &relay_file_operations);
1061         *is_global = 1;
1062         return buf_file;
1063 }
1064
1065 static int remove_buf_file_handler(struct dentry *dentry)
1066 {
1067         debugfs_remove(dentry);
1068
1069         return 0;
1070 }
1071
1072 static struct rchan_callbacks rfs_spec_scan_cb = {
1073         .create_buf_file = create_buf_file_handler,
1074         .remove_buf_file = remove_buf_file_handler,
1075 };
1076
1077 /*********************/
1078 /* Debug Init/Deinit */
1079 /*********************/
1080
1081 void ath9k_cmn_spectral_deinit_debug(struct ath_spec_scan_priv *spec_priv)
1082 {
1083         if (spec_priv->rfs_chan_spec_scan) {
1084                 relay_close(spec_priv->rfs_chan_spec_scan);
1085                 spec_priv->rfs_chan_spec_scan = NULL;
1086         }
1087 }
1088 EXPORT_SYMBOL(ath9k_cmn_spectral_deinit_debug);
1089
1090 void ath9k_cmn_spectral_init_debug(struct ath_spec_scan_priv *spec_priv,
1091                                    struct dentry *debugfs_phy)
1092 {
1093         spec_priv->rfs_chan_spec_scan = relay_open("spectral_scan",
1094                                             debugfs_phy,
1095                                             1024, 256, &rfs_spec_scan_cb,
1096                                             NULL);
1097         if (!spec_priv->rfs_chan_spec_scan)
1098                 return;
1099
1100         debugfs_create_file("spectral_scan_ctl",
1101                             S_IRUSR | S_IWUSR,
1102                             debugfs_phy, spec_priv,
1103                             &fops_spec_scan_ctl);
1104         debugfs_create_file("spectral_short_repeat",
1105                             S_IRUSR | S_IWUSR,
1106                             debugfs_phy, spec_priv,
1107                             &fops_spectral_short_repeat);
1108         debugfs_create_file("spectral_count",
1109                             S_IRUSR | S_IWUSR,
1110                             debugfs_phy, spec_priv,
1111                             &fops_spectral_count);
1112         debugfs_create_file("spectral_period",
1113                             S_IRUSR | S_IWUSR,
1114                             debugfs_phy, spec_priv,
1115                             &fops_spectral_period);
1116         debugfs_create_file("spectral_fft_period",
1117                             S_IRUSR | S_IWUSR,
1118                             debugfs_phy, spec_priv,
1119                             &fops_spectral_fft_period);
1120 }
1121 EXPORT_SYMBOL(ath9k_cmn_spectral_init_debug);