kernel/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 "ath9k.h"
  19
  20 static s8 fix_rssi_inv_only(u8 rssi_val)
  21 {
  22         if (rssi_val == 128)
  23                 rssi_val = 0;
  24         return (s8) rssi_val;
  25 }
  26
  27 static void ath_debug_send_fft_sample(struct ath_spec_scan_priv *spec_priv,
  28                                       struct fft_sample_tlv *fft_sample_tlv)
  29 {
  30         int length;
  31         if (!spec_priv->rfs_chan_spec_scan)
  32                 return;
  33
  34         length = __be16_to_cpu(fft_sample_tlv->length) +
  35                  sizeof(*fft_sample_tlv);
  36         relay_write(spec_priv->rfs_chan_spec_scan, fft_sample_tlv, length);
  37 }
  38
  39 /* returns 1 if this was a spectral frame, even if not handled. */
  40 int ath_cmn_process_fft(struct ath_spec_scan_priv *spec_priv, struct ieee80211_hdr *hdr,
  41                     struct ath_rx_status *rs, u64 tsf)
  42 {
  43         struct ath_hw *ah = spec_priv->ah;
  44         struct ath_common *common = ath9k_hw_common(spec_priv->ah);
  45         u8 num_bins, *bins, *vdata = (u8 *)hdr;
  46         struct fft_sample_ht20 fft_sample_20;
  47         struct fft_sample_ht20_40 fft_sample_40;
  48         struct fft_sample_tlv *tlv;
  49         struct ath_radar_info *radar_info;
  50         int len = rs->rs_datalen;
  51         int dc_pos;
  52         u16 fft_len, length, freq = ah->curchan->chan->center_freq;
  53         enum nl80211_channel_type chan_type;
  54
  55         /* AR9280 and before report via ATH9K_PHYERR_RADAR, AR93xx and newer
  56          * via ATH9K_PHYERR_SPECTRAL. Haven't seen ATH9K_PHYERR_FALSE_RADAR_EXT
  57          * yet, but this is supposed to be possible as well.
  58          */
  59         if (rs->rs_phyerr != ATH9K_PHYERR_RADAR &&
  60             rs->rs_phyerr != ATH9K_PHYERR_FALSE_RADAR_EXT &&
  61             rs->rs_phyerr != ATH9K_PHYERR_SPECTRAL)
  62                 return 0;
  63
  64         /* check if spectral scan bit is set. This does not have to be checked
  65          * if received through a SPECTRAL phy error, but shouldn't hurt.
  66          */
  67         radar_info = ((struct ath_radar_info *)&vdata[len]) - 1;
  68         if (!(radar_info->pulse_bw_info & SPECTRAL_SCAN_BITMASK))
  69                 return 0;
  70
  71         chan_type = cfg80211_get_chandef_type(&common->hw->conf.chandef);
  72         if ((chan_type == NL80211_CHAN_HT40MINUS) ||
  73             (chan_type == NL80211_CHAN_HT40PLUS)) {
  74                 fft_len = SPECTRAL_HT20_40_TOTAL_DATA_LEN;
  75                 num_bins = SPECTRAL_HT20_40_NUM_BINS;
  76                 bins = (u8 *)fft_sample_40.data;
  77         } else {
  78                 fft_len = SPECTRAL_HT20_TOTAL_DATA_LEN;
  79                 num_bins = SPECTRAL_HT20_NUM_BINS;
  80                 bins = (u8 *)fft_sample_20.data;
  81         }
  82
  83         /* Variation in the data length is possible and will be fixed later */
  84         if ((len > fft_len + 2) || (len < fft_len - 1))
  85                 return 1;
  86
  87         switch (len - fft_len) {
  88         case 0:
  89                 /* length correct, nothing to do. */
  90                 memcpy(bins, vdata, num_bins);
  91                 break;
  92         case -1:
  93                 /* first byte missing, duplicate it. */
  94                 memcpy(&bins[1], vdata, num_bins - 1);
  95                 bins[0] = vdata[0];
  96                 break;
  97         case 2:
  98                 /* MAC added 2 extra bytes at bin 30 and 32, remove them. */
  99                 memcpy(bins, vdata, 30);
 100                 bins[30] = vdata[31];
 101                 memcpy(&bins[31], &vdata[33], num_bins - 31);
 102                 break;
 103         case 1:
 104                 /* MAC added 2 extra bytes AND first byte is missing. */
 105                 bins[0] = vdata[0];
 106                 memcpy(&bins[1], vdata, 30);
 107                 bins[31] = vdata[31];
 108                 memcpy(&bins[32], &vdata[33], num_bins - 32);
 109                 break;
 110         default:
 111                 return 1;
 112         }
 113
 114         /* DC value (value in the middle) is the blind spot of the spectral
 115          * sample and invalid, interpolate it.
 116          */
 117         dc_pos = num_bins / 2;
 118         bins[dc_pos] = (bins[dc_pos + 1] + bins[dc_pos - 1]) / 2;
 119
 120         if ((chan_type == NL80211_CHAN_HT40MINUS) ||
 121             (chan_type == NL80211_CHAN_HT40PLUS)) {
 122                 s8 lower_rssi, upper_rssi;
 123                 s16 ext_nf;
 124                 u8 lower_max_index, upper_max_index;
 125                 u8 lower_bitmap_w, upper_bitmap_w;
 126                 u16 lower_mag, upper_mag;
 127                 struct ath9k_hw_cal_data *caldata = ah->caldata;
 128                 struct ath_ht20_40_mag_info *mag_info;
 129
 130                 if (caldata)
 131                         ext_nf = ath9k_hw_getchan_noise(ah, ah->curchan,
 132                                         caldata->nfCalHist[3].privNF);
 133                 else
 134                         ext_nf = ATH_DEFAULT_NOISE_FLOOR;
 135
 136                 length = sizeof(fft_sample_40) - sizeof(struct fft_sample_tlv);
 137                 fft_sample_40.tlv.type = ATH_FFT_SAMPLE_HT20_40;
 138                 fft_sample_40.tlv.length = __cpu_to_be16(length);
 139                 fft_sample_40.freq = __cpu_to_be16(freq);
 140                 fft_sample_40.channel_type = chan_type;
 141
 142                 if (chan_type == NL80211_CHAN_HT40PLUS) {
 143                         lower_rssi = fix_rssi_inv_only(rs->rs_rssi_ctl[0]);
 144                         upper_rssi = fix_rssi_inv_only(rs->rs_rssi_ext[0]);
 145
 146                         fft_sample_40.lower_noise = ah->noise;
 147                         fft_sample_40.upper_noise = ext_nf;
 148                 } else {
 149                         lower_rssi = fix_rssi_inv_only(rs->rs_rssi_ext[0]);
 150                         upper_rssi = fix_rssi_inv_only(rs->rs_rssi_ctl[0]);
 151
 152                         fft_sample_40.lower_noise = ext_nf;
 153                         fft_sample_40.upper_noise = ah->noise;
 154                 }
 155                 fft_sample_40.lower_rssi = lower_rssi;
 156                 fft_sample_40.upper_rssi = upper_rssi;
 157
 158                 mag_info = ((struct ath_ht20_40_mag_info *)radar_info) - 1;
 159                 lower_mag = spectral_max_magnitude(mag_info->lower_bins);
 160                 upper_mag = spectral_max_magnitude(mag_info->upper_bins);
 161                 fft_sample_40.lower_max_magnitude = __cpu_to_be16(lower_mag);
 162                 fft_sample_40.upper_max_magnitude = __cpu_to_be16(upper_mag);
 163                 lower_max_index = spectral_max_index(mag_info->lower_bins);
 164                 upper_max_index = spectral_max_index(mag_info->upper_bins);
 165                 fft_sample_40.lower_max_index = lower_max_index;
 166                 fft_sample_40.upper_max_index = upper_max_index;
 167                 lower_bitmap_w = spectral_bitmap_weight(mag_info->lower_bins);
 168                 upper_bitmap_w = spectral_bitmap_weight(mag_info->upper_bins);
 169                 fft_sample_40.lower_bitmap_weight = lower_bitmap_w;
 170                 fft_sample_40.upper_bitmap_weight = upper_bitmap_w;
 171                 fft_sample_40.max_exp = mag_info->max_exp & 0xf;
 172
 173                 fft_sample_40.tsf = __cpu_to_be64(tsf);
 174
 175                 tlv = (struct fft_sample_tlv *)&fft_sample_40;
 176         } else {
 177                 u8 max_index, bitmap_w;
 178                 u16 magnitude;
 179                 struct ath_ht20_mag_info *mag_info;
 180
 181                 length = sizeof(fft_sample_20) - sizeof(struct fft_sample_tlv);
 182                 fft_sample_20.tlv.type = ATH_FFT_SAMPLE_HT20;
 183                 fft_sample_20.tlv.length = __cpu_to_be16(length);
 184                 fft_sample_20.freq = __cpu_to_be16(freq);
 185
 186                 fft_sample_20.rssi = fix_rssi_inv_only(rs->rs_rssi_ctl[0]);
 187                 fft_sample_20.noise = ah->noise;
 188
 189                 mag_info = ((struct ath_ht20_mag_info *)radar_info) - 1;
 190                 magnitude = spectral_max_magnitude(mag_info->all_bins);
 191                 fft_sample_20.max_magnitude = __cpu_to_be16(magnitude);
 192                 max_index = spectral_max_index(mag_info->all_bins);
 193                 fft_sample_20.max_index = max_index;
 194                 bitmap_w = spectral_bitmap_weight(mag_info->all_bins);
 195                 fft_sample_20.bitmap_weight = bitmap_w;
 196                 fft_sample_20.max_exp = mag_info->max_exp & 0xf;
 197
 198                 fft_sample_20.tsf = __cpu_to_be64(tsf);
 199
 200                 tlv = (struct fft_sample_tlv *)&fft_sample_20;
 201         }
 202
 203         ath_debug_send_fft_sample(spec_priv, tlv);
 204
 205         return 1;
 206 }
 207 EXPORT_SYMBOL(ath_cmn_process_fft);
 208
 209 /*********************/
 210 /* spectral_scan_ctl */
 211 /*********************/
 212
 213 static ssize_t read_file_spec_scan_ctl(struct file *file, char __user *user_buf,
 214                                        size_t count, loff_t *ppos)
 215 {
 216         struct ath_spec_scan_priv *spec_priv = file->private_data;
 217         char *mode = "";
 218         unsigned int len;
 219
 220         switch (spec_priv->spectral_mode) {
 221         case SPECTRAL_DISABLED:
 222                 mode = "disable";
 223                 break;
 224         case SPECTRAL_BACKGROUND:
 225                 mode = "background";
 226                 break;
 227         case SPECTRAL_CHANSCAN:
 228                 mode = "chanscan";
 229                 break;
 230         case SPECTRAL_MANUAL:
 231                 mode = "manual";
 232                 break;
 233         }
 234         len = strlen(mode);
 235         return simple_read_from_buffer(user_buf, count, ppos, mode, len);
 236 }
 237
 238 void ath9k_cmn_spectral_scan_trigger(struct ath_common *common,
 239                                  struct ath_spec_scan_priv *spec_priv)
 240 {
 241         struct ath_hw *ah = spec_priv->ah;
 242         u32 rxfilter;
 243
 244         if (config_enabled(CONFIG_ATH9K_TX99))
 245                 return;
 246
 247         if (!ath9k_hw_ops(ah)->spectral_scan_trigger) {
 248                 ath_err(common, "spectrum analyzer not implemented on this hardware\n");
 249                 return;
 250         }
 251
 252         ath_ps_ops(common)->wakeup(common);
 253         rxfilter = ath9k_hw_getrxfilter(ah);
 254         ath9k_hw_setrxfilter(ah, rxfilter |
 255                                  ATH9K_RX_FILTER_PHYRADAR |
 256                                  ATH9K_RX_FILTER_PHYERR);
 257
 258         /* TODO: usually this should not be neccesary, but for some reason
 259          * (or in some mode?) the trigger must be called after the
 260          * configuration, otherwise the register will have its values reset
 261          * (on my ar9220 to value 0x01002310)
 262          */
 263         ath9k_cmn_spectral_scan_config(common, spec_priv, spec_priv->spectral_mode);
 264         ath9k_hw_ops(ah)->spectral_scan_trigger(ah);
 265         ath_ps_ops(common)->restore(common);
 266 }
 267 EXPORT_SYMBOL(ath9k_cmn_spectral_scan_trigger);
 268
 269 int ath9k_cmn_spectral_scan_config(struct ath_common *common,
 270                                struct ath_spec_scan_priv *spec_priv,
 271                                enum spectral_mode spectral_mode)
 272 {
 273         struct ath_hw *ah = spec_priv->ah;
 274
 275         if (!ath9k_hw_ops(ah)->spectral_scan_trigger) {
 276                 ath_err(common, "spectrum analyzer not implemented on this hardware\n");
 277                 return -1;
 278         }
 279
 280         switch (spectral_mode) {
 281         case SPECTRAL_DISABLED:
 282                 spec_priv->spec_config.enabled = 0;
 283                 break;
 284         case SPECTRAL_BACKGROUND:
 285                 /* send endless samples.
 286                  * TODO: is this really useful for "background"?
 287                  */
 288                 spec_priv->spec_config.endless = 1;
 289                 spec_priv->spec_config.enabled = 1;
 290                 break;
 291         case SPECTRAL_CHANSCAN:
 292         case SPECTRAL_MANUAL:
 293                 spec_priv->spec_config.endless = 0;
 294                 spec_priv->spec_config.enabled = 1;
 295                 break;
 296         default:
 297                 return -1;
 298         }
 299
 300         ath_ps_ops(common)->wakeup(common);
 301         ath9k_hw_ops(ah)->spectral_scan_config(ah, &spec_priv->spec_config);
 302         ath_ps_ops(common)->restore(common);
 303
 304         spec_priv->spectral_mode = spectral_mode;
 305
 306         return 0;
 307 }
 308 EXPORT_SYMBOL(ath9k_cmn_spectral_scan_config);
 309
 310 static ssize_t write_file_spec_scan_ctl(struct file *file,
 311                                         const char __user *user_buf,
 312                                         size_t count, loff_t *ppos)
 313 {
 314         struct ath_spec_scan_priv *spec_priv = file->private_data;
 315         struct ath_common *common = ath9k_hw_common(spec_priv->ah);
 316         char buf[32];
 317         ssize_t len;
 318
 319         if (config_enabled(CONFIG_ATH9K_TX99))
 320                 return -EOPNOTSUPP;
 321
 322         len = min(count, sizeof(buf) - 1);
 323         if (copy_from_user(buf, user_buf, len))
 324                 return -EFAULT;
 325
 326         buf[len] = '\0';
 327
 328         if (strncmp("trigger", buf, 7) == 0) {
 329                 ath9k_cmn_spectral_scan_trigger(common, spec_priv);
 330         } else if (strncmp("background", buf, 10) == 0) {
 331                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_BACKGROUND);
 332                 ath_dbg(common, CONFIG, "spectral scan: background mode enabled\n");
 333         } else if (strncmp("chanscan", buf, 8) == 0) {
 334                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_CHANSCAN);
 335                 ath_dbg(common, CONFIG, "spectral scan: channel scan mode enabled\n");
 336         } else if (strncmp("manual", buf, 6) == 0) {
 337                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_MANUAL);
 338                 ath_dbg(common, CONFIG, "spectral scan: manual mode enabled\n");
 339         } else if (strncmp("disable", buf, 7) == 0) {
 340                 ath9k_cmn_spectral_scan_config(common, spec_priv, SPECTRAL_DISABLED);
 341                 ath_dbg(common, CONFIG, "spectral scan: disabled\n");
 342         } else {
 343                 return -EINVAL;
 344         }
 345
 346         return count;
 347 }
 348
 349 static const struct file_operations fops_spec_scan_ctl = {
 350         .read = read_file_spec_scan_ctl,
 351         .write = write_file_spec_scan_ctl,
 352         .open = simple_open,
 353         .owner = THIS_MODULE,
 354         .llseek = default_llseek,
 355 };
 356
 357 /*************************/
 358 /* spectral_short_repeat */
 359 /*************************/
 360
 361 static ssize_t read_file_spectral_short_repeat(struct file *file,
 362                                                char __user *user_buf,
 363                                                size_t count, loff_t *ppos)
 364 {
 365         struct ath_spec_scan_priv *spec_priv = file->private_data;
 366         char buf[32];
 367         unsigned int len;
 368
 369         len = sprintf(buf, "%d\n", spec_priv->spec_config.short_repeat);
 370         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 371 }
 372
 373 static ssize_t write_file_spectral_short_repeat(struct file *file,
 374                                                 const char __user *user_buf,
 375                                                 size_t count, loff_t *ppos)
 376 {
 377         struct ath_spec_scan_priv *spec_priv = file->private_data;
 378         unsigned long val;
 379         char buf[32];
 380         ssize_t len;
 381
 382         len = min(count, sizeof(buf) - 1);
 383         if (copy_from_user(buf, user_buf, len))
 384                 return -EFAULT;
 385
 386         buf[len] = '\0';
 387         if (kstrtoul(buf, 0, &val))
 388                 return -EINVAL;
 389
 390         if (val > 1)
 391                 return -EINVAL;
 392
 393         spec_priv->spec_config.short_repeat = val;
 394         return count;
 395 }
 396
 397 static const struct file_operations fops_spectral_short_repeat = {
 398         .read = read_file_spectral_short_repeat,
 399         .write = write_file_spectral_short_repeat,
 400         .open = simple_open,
 401         .owner = THIS_MODULE,
 402         .llseek = default_llseek,
 403 };
 404
 405 /******************/
 406 /* spectral_count */
 407 /******************/
 408
 409 static ssize_t read_file_spectral_count(struct file *file,
 410                                         char __user *user_buf,
 411                                         size_t count, loff_t *ppos)
 412 {
 413         struct ath_spec_scan_priv *spec_priv = file->private_data;
 414         char buf[32];
 415         unsigned int len;
 416
 417         len = sprintf(buf, "%d\n", spec_priv->spec_config.count);
 418         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 419 }
 420
 421 static ssize_t write_file_spectral_count(struct file *file,
 422                                          const char __user *user_buf,
 423                                          size_t count, loff_t *ppos)
 424 {
 425         struct ath_spec_scan_priv *spec_priv = file->private_data;
 426         unsigned long val;
 427         char buf[32];
 428         ssize_t len;
 429
 430         len = min(count, sizeof(buf) - 1);
 431         if (copy_from_user(buf, user_buf, len))
 432                 return -EFAULT;
 433
 434         buf[len] = '\0';
 435         if (kstrtoul(buf, 0, &val))
 436                 return -EINVAL;
 437
 438         if (val > 255)
 439                 return -EINVAL;
 440
 441         spec_priv->spec_config.count = val;
 442         return count;
 443 }
 444
 445 static const struct file_operations fops_spectral_count = {
 446         .read = read_file_spectral_count,
 447         .write = write_file_spectral_count,
 448         .open = simple_open,
 449         .owner = THIS_MODULE,
 450         .llseek = default_llseek,
 451 };
 452
 453 /*******************/
 454 /* spectral_period */
 455 /*******************/
 456
 457 static ssize_t read_file_spectral_period(struct file *file,
 458                                          char __user *user_buf,
 459                                          size_t count, loff_t *ppos)
 460 {
 461         struct ath_spec_scan_priv *spec_priv = file->private_data;
 462         char buf[32];
 463         unsigned int len;
 464
 465         len = sprintf(buf, "%d\n", spec_priv->spec_config.period);
 466         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 467 }
 468
 469 static ssize_t write_file_spectral_period(struct file *file,
 470                                           const char __user *user_buf,
 471                                           size_t count, loff_t *ppos)
 472 {
 473         struct ath_spec_scan_priv *spec_priv = file->private_data;
 474         unsigned long val;
 475         char buf[32];
 476         ssize_t len;
 477
 478         len = min(count, sizeof(buf) - 1);
 479         if (copy_from_user(buf, user_buf, len))
 480                 return -EFAULT;
 481
 482         buf[len] = '\0';
 483         if (kstrtoul(buf, 0, &val))
 484                 return -EINVAL;
 485
 486         if (val > 255)
 487                 return -EINVAL;
 488
 489         spec_priv->spec_config.period = val;
 490         return count;
 491 }
 492
 493 static const struct file_operations fops_spectral_period = {
 494         .read = read_file_spectral_period,
 495         .write = write_file_spectral_period,
 496         .open = simple_open,
 497         .owner = THIS_MODULE,
 498         .llseek = default_llseek,
 499 };
 500
 501 /***********************/
 502 /* spectral_fft_period */
 503 /***********************/
 504
 505 static ssize_t read_file_spectral_fft_period(struct file *file,
 506                                              char __user *user_buf,
 507                                              size_t count, loff_t *ppos)
 508 {
 509         struct ath_spec_scan_priv *spec_priv = file->private_data;
 510         char buf[32];
 511         unsigned int len;
 512
 513         len = sprintf(buf, "%d\n", spec_priv->spec_config.fft_period);
 514         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 515 }
 516
 517 static ssize_t write_file_spectral_fft_period(struct file *file,
 518                                               const char __user *user_buf,
 519                                               size_t count, loff_t *ppos)
 520 {
 521         struct ath_spec_scan_priv *spec_priv = file->private_data;
 522         unsigned long val;
 523         char buf[32];
 524         ssize_t len;
 525
 526         len = min(count, sizeof(buf) - 1);
 527         if (copy_from_user(buf, user_buf, len))
 528                 return -EFAULT;
 529
 530         buf[len] = '\0';
 531         if (kstrtoul(buf, 0, &val))
 532                 return -EINVAL;
 533
 534         if (val > 15)
 535                 return -EINVAL;
 536
 537         spec_priv->spec_config.fft_period = val;
 538         return count;
 539 }
 540
 541 static const struct file_operations fops_spectral_fft_period = {
 542         .read = read_file_spectral_fft_period,
 543         .write = write_file_spectral_fft_period,
 544         .open = simple_open,
 545         .owner = THIS_MODULE,
 546         .llseek = default_llseek,
 547 };
 548
 549 /*******************/
 550 /* Relay interface */
 551 /*******************/
 552
 553 static struct dentry *create_buf_file_handler(const char *filename,
 554                                               struct dentry *parent,
 555                                               umode_t mode,
 556                                               struct rchan_buf *buf,
 557                                               int *is_global)
 558 {
 559         struct dentry *buf_file;
 560
 561         buf_file = debugfs_create_file(filename, mode, parent, buf,
 562                                        &relay_file_operations);
 563         *is_global = 1;
 564         return buf_file;
 565 }
 566
 567 static int remove_buf_file_handler(struct dentry *dentry)
 568 {
 569         debugfs_remove(dentry);
 570
 571         return 0;
 572 }
 573
 574 static struct rchan_callbacks rfs_spec_scan_cb = {
 575         .create_buf_file = create_buf_file_handler,
 576         .remove_buf_file = remove_buf_file_handler,
 577 };
 578
 579 /*********************/
 580 /* Debug Init/Deinit */
 581 /*********************/
 582
 583 void ath9k_cmn_spectral_deinit_debug(struct ath_spec_scan_priv *spec_priv)
 584 {
 585         if (config_enabled(CONFIG_ATH9K_DEBUGFS)) {
 586                 relay_close(spec_priv->rfs_chan_spec_scan);
 587                 spec_priv->rfs_chan_spec_scan = NULL;
 588         }
 589 }
 590 EXPORT_SYMBOL(ath9k_cmn_spectral_deinit_debug);
 591
 592 void ath9k_cmn_spectral_init_debug(struct ath_spec_scan_priv *spec_priv,
 593                                    struct dentry *debugfs_phy)
 594 {
 595         spec_priv->rfs_chan_spec_scan = relay_open("spectral_scan",
 596                                             debugfs_phy,
 597                                             1024, 256, &rfs_spec_scan_cb,
 598                                             NULL);
 599         debugfs_create_file("spectral_scan_ctl",
 600                             S_IRUSR | S_IWUSR,
 601                             debugfs_phy, spec_priv,
 602                             &fops_spec_scan_ctl);
 603         debugfs_create_file("spectral_short_repeat",
 604                             S_IRUSR | S_IWUSR,
 605                             debugfs_phy, spec_priv,
 606                             &fops_spectral_short_repeat);
 607         debugfs_create_file("spectral_count",
 608                             S_IRUSR | S_IWUSR,
 609                             debugfs_phy, spec_priv,
 610                             &fops_spectral_count);
 611         debugfs_create_file("spectral_period",
 612                             S_IRUSR | S_IWUSR,
 613                             debugfs_phy, spec_priv,
 614                             &fops_spectral_period);
 615         debugfs_create_file("spectral_fft_period",
 616                             S_IRUSR | S_IWUSR,
 617                             debugfs_phy, spec_priv,
 618                             &fops_spectral_fft_period);
 619 }
 620 EXPORT_SYMBOL(ath9k_cmn_spectral_init_debug);