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 0600, 1102 debugfs_phy, spec_priv, 1103 &fops_spec_scan_ctl); 1104 debugfs_create_file("spectral_short_repeat", 1105 0600, 1106 debugfs_phy, spec_priv, 1107 &fops_spectral_short_repeat); 1108 debugfs_create_file("spectral_count", 1109 0600, 1110 debugfs_phy, spec_priv, 1111 &fops_spectral_count); 1112 debugfs_create_file("spectral_period", 1113 0600, 1114 debugfs_phy, spec_priv, 1115 &fops_spectral_period); 1116 debugfs_create_file("spectral_fft_period", 1117 0600, 1118 debugfs_phy, spec_priv, 1119 &fops_spectral_fft_period); 1120 } 1121 EXPORT_SYMBOL(ath9k_cmn_spectral_init_debug); 1122