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); 1111