linux/drivers/net/wireless/ath/ath9k/htc_drv_debug.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2010-2011 Atheros Communications 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 "htc.h"
  18
  19static ssize_t read_file_tgt_int_stats(struct file *file, char __user *user_buf,
  20                                       size_t count, loff_t *ppos)
  21{
  22        struct ath9k_htc_priv *priv = file->private_data;
  23        struct ath9k_htc_target_int_stats cmd_rsp;
  24        char buf[512];
  25        unsigned int len = 0;
  26        int ret = 0;
  27
  28        memset(&cmd_rsp, 0, sizeof(cmd_rsp));
  29
  30        ath9k_htc_ps_wakeup(priv);
  31
  32        WMI_CMD(WMI_INT_STATS_CMDID);
  33        if (ret) {
  34                ath9k_htc_ps_restore(priv);
  35                return -EINVAL;
  36        }
  37
  38        ath9k_htc_ps_restore(priv);
  39
  40        len += scnprintf(buf + len, sizeof(buf) - len,
  41                         "%20s : %10u\n", "RX",
  42                         be32_to_cpu(cmd_rsp.rx));
  43
  44        len += scnprintf(buf + len, sizeof(buf) - len,
  45                         "%20s : %10u\n", "RXORN",
  46                         be32_to_cpu(cmd_rsp.rxorn));
  47
  48        len += scnprintf(buf + len, sizeof(buf) - len,
  49                         "%20s : %10u\n", "RXEOL",
  50                         be32_to_cpu(cmd_rsp.rxeol));
  51
  52        len += scnprintf(buf + len, sizeof(buf) - len,
  53                         "%20s : %10u\n", "TXURN",
  54                         be32_to_cpu(cmd_rsp.txurn));
  55
  56        len += scnprintf(buf + len, sizeof(buf) - len,
  57                         "%20s : %10u\n", "TXTO",
  58                         be32_to_cpu(cmd_rsp.txto));
  59
  60        len += scnprintf(buf + len, sizeof(buf) - len,
  61                         "%20s : %10u\n", "CST",
  62                         be32_to_cpu(cmd_rsp.cst));
  63
  64        if (len > sizeof(buf))
  65                len = sizeof(buf);
  66
  67        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
  68}
  69
  70static const struct file_operations fops_tgt_int_stats = {
  71        .read = read_file_tgt_int_stats,
  72        .open = simple_open,
  73        .owner = THIS_MODULE,
  74        .llseek = default_llseek,
  75};
  76
  77static ssize_t read_file_tgt_tx_stats(struct file *file, char __user *user_buf,
  78                                      size_t count, loff_t *ppos)
  79{
  80        struct ath9k_htc_priv *priv = file->private_data;
  81        struct ath9k_htc_target_tx_stats cmd_rsp;
  82        char buf[512];
  83        unsigned int len = 0;
  84        int ret = 0;
  85
  86        memset(&cmd_rsp, 0, sizeof(cmd_rsp));
  87
  88        ath9k_htc_ps_wakeup(priv);
  89
  90        WMI_CMD(WMI_TX_STATS_CMDID);
  91        if (ret) {
  92                ath9k_htc_ps_restore(priv);
  93                return -EINVAL;
  94        }
  95
  96        ath9k_htc_ps_restore(priv);
  97
  98        len += scnprintf(buf + len, sizeof(buf) - len,
  99                         "%20s : %10u\n", "Xretries",
 100                         be32_to_cpu(cmd_rsp.xretries));
 101
 102        len += scnprintf(buf + len, sizeof(buf) - len,
 103                         "%20s : %10u\n", "FifoErr",
 104                         be32_to_cpu(cmd_rsp.fifoerr));
 105
 106        len += scnprintf(buf + len, sizeof(buf) - len,
 107                         "%20s : %10u\n", "Filtered",
 108                         be32_to_cpu(cmd_rsp.filtered));
 109
 110        len += scnprintf(buf + len, sizeof(buf) - len,
 111                         "%20s : %10u\n", "TimerExp",
 112                         be32_to_cpu(cmd_rsp.timer_exp));
 113
 114        len += scnprintf(buf + len, sizeof(buf) - len,
 115                         "%20s : %10u\n", "ShortRetries",
 116                         be32_to_cpu(cmd_rsp.shortretries));
 117
 118        len += scnprintf(buf + len, sizeof(buf) - len,
 119                         "%20s : %10u\n", "LongRetries",
 120                         be32_to_cpu(cmd_rsp.longretries));
 121
 122        len += scnprintf(buf + len, sizeof(buf) - len,
 123                         "%20s : %10u\n", "QueueNull",
 124                         be32_to_cpu(cmd_rsp.qnull));
 125
 126        len += scnprintf(buf + len, sizeof(buf) - len,
 127                         "%20s : %10u\n", "EncapFail",
 128                         be32_to_cpu(cmd_rsp.encap_fail));
 129
 130        len += scnprintf(buf + len, sizeof(buf) - len,
 131                         "%20s : %10u\n", "NoBuf",
 132                         be32_to_cpu(cmd_rsp.nobuf));
 133
 134        if (len > sizeof(buf))
 135                len = sizeof(buf);
 136
 137        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 138}
 139
 140static const struct file_operations fops_tgt_tx_stats = {
 141        .read = read_file_tgt_tx_stats,
 142        .open = simple_open,
 143        .owner = THIS_MODULE,
 144        .llseek = default_llseek,
 145};
 146
 147static ssize_t read_file_tgt_rx_stats(struct file *file, char __user *user_buf,
 148                                      size_t count, loff_t *ppos)
 149{
 150        struct ath9k_htc_priv *priv = file->private_data;
 151        struct ath9k_htc_target_rx_stats cmd_rsp;
 152        char buf[512];
 153        unsigned int len = 0;
 154        int ret = 0;
 155
 156        memset(&cmd_rsp, 0, sizeof(cmd_rsp));
 157
 158        ath9k_htc_ps_wakeup(priv);
 159
 160        WMI_CMD(WMI_RX_STATS_CMDID);
 161        if (ret) {
 162                ath9k_htc_ps_restore(priv);
 163                return -EINVAL;
 164        }
 165
 166        ath9k_htc_ps_restore(priv);
 167
 168        len += scnprintf(buf + len, sizeof(buf) - len,
 169                         "%20s : %10u\n", "NoBuf",
 170                         be32_to_cpu(cmd_rsp.nobuf));
 171
 172        len += scnprintf(buf + len, sizeof(buf) - len,
 173                         "%20s : %10u\n", "HostSend",
 174                         be32_to_cpu(cmd_rsp.host_send));
 175
 176        len += scnprintf(buf + len, sizeof(buf) - len,
 177                         "%20s : %10u\n", "HostDone",
 178                         be32_to_cpu(cmd_rsp.host_done));
 179
 180        if (len > sizeof(buf))
 181                len = sizeof(buf);
 182
 183        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 184}
 185
 186static const struct file_operations fops_tgt_rx_stats = {
 187        .read = read_file_tgt_rx_stats,
 188        .open = simple_open,
 189        .owner = THIS_MODULE,
 190        .llseek = default_llseek,
 191};
 192
 193static ssize_t read_file_xmit(struct file *file, char __user *user_buf,
 194                              size_t count, loff_t *ppos)
 195{
 196        struct ath9k_htc_priv *priv = file->private_data;
 197        char buf[512];
 198        unsigned int len = 0;
 199
 200        len += scnprintf(buf + len, sizeof(buf) - len,
 201                         "%20s : %10u\n", "Buffers queued",
 202                         priv->debug.tx_stats.buf_queued);
 203        len += scnprintf(buf + len, sizeof(buf) - len,
 204                         "%20s : %10u\n", "Buffers completed",
 205                         priv->debug.tx_stats.buf_completed);
 206        len += scnprintf(buf + len, sizeof(buf) - len,
 207                         "%20s : %10u\n", "SKBs queued",
 208                         priv->debug.tx_stats.skb_queued);
 209        len += scnprintf(buf + len, sizeof(buf) - len,
 210                         "%20s : %10u\n", "SKBs success",
 211                         priv->debug.tx_stats.skb_success);
 212        len += scnprintf(buf + len, sizeof(buf) - len,
 213                         "%20s : %10u\n", "SKBs failed",
 214                         priv->debug.tx_stats.skb_failed);
 215        len += scnprintf(buf + len, sizeof(buf) - len,
 216                         "%20s : %10u\n", "CAB queued",
 217                         priv->debug.tx_stats.cab_queued);
 218
 219        len += scnprintf(buf + len, sizeof(buf) - len,
 220                         "%20s : %10u\n", "BE queued",
 221                         priv->debug.tx_stats.queue_stats[IEEE80211_AC_BE]);
 222        len += scnprintf(buf + len, sizeof(buf) - len,
 223                         "%20s : %10u\n", "BK queued",
 224                         priv->debug.tx_stats.queue_stats[IEEE80211_AC_BK]);
 225        len += scnprintf(buf + len, sizeof(buf) - len,
 226                         "%20s : %10u\n", "VI queued",
 227                         priv->debug.tx_stats.queue_stats[IEEE80211_AC_VI]);
 228        len += scnprintf(buf + len, sizeof(buf) - len,
 229                         "%20s : %10u\n", "VO queued",
 230                         priv->debug.tx_stats.queue_stats[IEEE80211_AC_VO]);
 231
 232        if (len > sizeof(buf))
 233                len = sizeof(buf);
 234
 235        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 236}
 237
 238static const struct file_operations fops_xmit = {
 239        .read = read_file_xmit,
 240        .open = simple_open,
 241        .owner = THIS_MODULE,
 242        .llseek = default_llseek,
 243};
 244
 245void ath9k_htc_err_stat_rx(struct ath9k_htc_priv *priv,
 246                           struct ath_htc_rx_status *rxs)
 247{
 248#define RX_PHY_ERR_INC(c) priv->debug.rx_stats.err_phy_stats[c]++
 249
 250        if (rxs->rs_status & ATH9K_RXERR_CRC)
 251                priv->debug.rx_stats.err_crc++;
 252        if (rxs->rs_status & ATH9K_RXERR_DECRYPT)
 253                priv->debug.rx_stats.err_decrypt_crc++;
 254        if (rxs->rs_status & ATH9K_RXERR_MIC)
 255                priv->debug.rx_stats.err_mic++;
 256        if (rxs->rs_status & ATH9K_RX_DELIM_CRC_PRE)
 257                priv->debug.rx_stats.err_pre_delim++;
 258        if (rxs->rs_status & ATH9K_RX_DELIM_CRC_POST)
 259                priv->debug.rx_stats.err_post_delim++;
 260        if (rxs->rs_status & ATH9K_RX_DECRYPT_BUSY)
 261                priv->debug.rx_stats.err_decrypt_busy++;
 262
 263        if (rxs->rs_status & ATH9K_RXERR_PHY) {
 264                priv->debug.rx_stats.err_phy++;
 265                if (rxs->rs_phyerr < ATH9K_PHYERR_MAX)
 266                        RX_PHY_ERR_INC(rxs->rs_phyerr);
 267        }
 268
 269#undef RX_PHY_ERR_INC
 270}
 271
 272static ssize_t read_file_recv(struct file *file, char __user *user_buf,
 273                              size_t count, loff_t *ppos)
 274{
 275#define PHY_ERR(s, p)                                                   \
 276        len += scnprintf(buf + len, size - len, "%20s : %10u\n", s,     \
 277                         priv->debug.rx_stats.err_phy_stats[p]);
 278
 279        struct ath9k_htc_priv *priv = file->private_data;
 280        char *buf;
 281        unsigned int len = 0, size = 1500;
 282        ssize_t retval = 0;
 283
 284        buf = kzalloc(size, GFP_KERNEL);
 285        if (buf == NULL)
 286                return -ENOMEM;
 287
 288        len += scnprintf(buf + len, size - len,
 289                         "%20s : %10u\n", "SKBs allocated",
 290                         priv->debug.rx_stats.skb_allocated);
 291        len += scnprintf(buf + len, size - len,
 292                         "%20s : %10u\n", "SKBs completed",
 293                         priv->debug.rx_stats.skb_completed);
 294        len += scnprintf(buf + len, size - len,
 295                         "%20s : %10u\n", "SKBs Dropped",
 296                         priv->debug.rx_stats.skb_dropped);
 297
 298        len += scnprintf(buf + len, size - len,
 299                         "%20s : %10u\n", "CRC ERR",
 300                         priv->debug.rx_stats.err_crc);
 301        len += scnprintf(buf + len, size - len,
 302                         "%20s : %10u\n", "DECRYPT CRC ERR",
 303                         priv->debug.rx_stats.err_decrypt_crc);
 304        len += scnprintf(buf + len, size - len,
 305                         "%20s : %10u\n", "MIC ERR",
 306                         priv->debug.rx_stats.err_mic);
 307        len += scnprintf(buf + len, size - len,
 308                         "%20s : %10u\n", "PRE-DELIM CRC ERR",
 309                         priv->debug.rx_stats.err_pre_delim);
 310        len += scnprintf(buf + len, size - len,
 311                         "%20s : %10u\n", "POST-DELIM CRC ERR",
 312                         priv->debug.rx_stats.err_post_delim);
 313        len += scnprintf(buf + len, size - len,
 314                         "%20s : %10u\n", "DECRYPT BUSY ERR",
 315                         priv->debug.rx_stats.err_decrypt_busy);
 316        len += scnprintf(buf + len, size - len,
 317                         "%20s : %10u\n", "TOTAL PHY ERR",
 318                         priv->debug.rx_stats.err_phy);
 319
 320
 321        PHY_ERR("UNDERRUN", ATH9K_PHYERR_UNDERRUN);
 322        PHY_ERR("TIMING", ATH9K_PHYERR_TIMING);
 323        PHY_ERR("PARITY", ATH9K_PHYERR_PARITY);
 324        PHY_ERR("RATE", ATH9K_PHYERR_RATE);
 325        PHY_ERR("LENGTH", ATH9K_PHYERR_LENGTH);
 326        PHY_ERR("RADAR", ATH9K_PHYERR_RADAR);
 327        PHY_ERR("SERVICE", ATH9K_PHYERR_SERVICE);
 328        PHY_ERR("TOR", ATH9K_PHYERR_TOR);
 329        PHY_ERR("OFDM-TIMING", ATH9K_PHYERR_OFDM_TIMING);
 330        PHY_ERR("OFDM-SIGNAL-PARITY", ATH9K_PHYERR_OFDM_SIGNAL_PARITY);
 331        PHY_ERR("OFDM-RATE", ATH9K_PHYERR_OFDM_RATE_ILLEGAL);
 332        PHY_ERR("OFDM-LENGTH", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL);
 333        PHY_ERR("OFDM-POWER-DROP", ATH9K_PHYERR_OFDM_POWER_DROP);
 334        PHY_ERR("OFDM-SERVICE", ATH9K_PHYERR_OFDM_SERVICE);
 335        PHY_ERR("OFDM-RESTART", ATH9K_PHYERR_OFDM_RESTART);
 336        PHY_ERR("FALSE-RADAR-EXT", ATH9K_PHYERR_FALSE_RADAR_EXT);
 337        PHY_ERR("CCK-TIMING", ATH9K_PHYERR_CCK_TIMING);
 338        PHY_ERR("CCK-HEADER-CRC", ATH9K_PHYERR_CCK_HEADER_CRC);
 339        PHY_ERR("CCK-RATE", ATH9K_PHYERR_CCK_RATE_ILLEGAL);
 340        PHY_ERR("CCK-SERVICE", ATH9K_PHYERR_CCK_SERVICE);
 341        PHY_ERR("CCK-RESTART", ATH9K_PHYERR_CCK_RESTART);
 342        PHY_ERR("CCK-LENGTH", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL);
 343        PHY_ERR("CCK-POWER-DROP", ATH9K_PHYERR_CCK_POWER_DROP);
 344        PHY_ERR("HT-CRC", ATH9K_PHYERR_HT_CRC_ERROR);
 345        PHY_ERR("HT-LENGTH", ATH9K_PHYERR_HT_LENGTH_ILLEGAL);
 346        PHY_ERR("HT-RATE", ATH9K_PHYERR_HT_RATE_ILLEGAL);
 347
 348        if (len > size)
 349                len = size;
 350
 351        retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 352        kfree(buf);
 353
 354        return retval;
 355
 356#undef PHY_ERR
 357}
 358
 359static const struct file_operations fops_recv = {
 360        .read = read_file_recv,
 361        .open = simple_open,
 362        .owner = THIS_MODULE,
 363        .llseek = default_llseek,
 364};
 365
 366static ssize_t read_file_slot(struct file *file, char __user *user_buf,
 367                              size_t count, loff_t *ppos)
 368{
 369        struct ath9k_htc_priv *priv = file->private_data;
 370        char buf[512];
 371        unsigned int len = 0;
 372
 373        spin_lock_bh(&priv->tx.tx_lock);
 374
 375        len += scnprintf(buf + len, sizeof(buf) - len, "TX slot bitmap : ");
 376
 377        len += bitmap_scnprintf(buf + len, sizeof(buf) - len,
 378                               priv->tx.tx_slot, MAX_TX_BUF_NUM);
 379
 380        len += scnprintf(buf + len, sizeof(buf) - len, "\n");
 381
 382        len += scnprintf(buf + len, sizeof(buf) - len,
 383                         "Used slots     : %d\n",
 384                         bitmap_weight(priv->tx.tx_slot, MAX_TX_BUF_NUM));
 385
 386        spin_unlock_bh(&priv->tx.tx_lock);
 387
 388        if (len > sizeof(buf))
 389                len = sizeof(buf);
 390
 391        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 392}
 393
 394static const struct file_operations fops_slot = {
 395        .read = read_file_slot,
 396        .open = simple_open,
 397        .owner = THIS_MODULE,
 398        .llseek = default_llseek,
 399};
 400
 401static ssize_t read_file_queue(struct file *file, char __user *user_buf,
 402                               size_t count, loff_t *ppos)
 403{
 404        struct ath9k_htc_priv *priv = file->private_data;
 405        char buf[512];
 406        unsigned int len = 0;
 407
 408        len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
 409                         "Mgmt endpoint", skb_queue_len(&priv->tx.mgmt_ep_queue));
 410
 411        len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
 412                         "Cab endpoint", skb_queue_len(&priv->tx.cab_ep_queue));
 413
 414        len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
 415                         "Data BE endpoint", skb_queue_len(&priv->tx.data_be_queue));
 416
 417        len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
 418                         "Data BK endpoint", skb_queue_len(&priv->tx.data_bk_queue));
 419
 420        len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
 421                         "Data VI endpoint", skb_queue_len(&priv->tx.data_vi_queue));
 422
 423        len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
 424                         "Data VO endpoint", skb_queue_len(&priv->tx.data_vo_queue));
 425
 426        len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
 427                         "Failed queue", skb_queue_len(&priv->tx.tx_failed));
 428
 429        spin_lock_bh(&priv->tx.tx_lock);
 430        len += scnprintf(buf + len, sizeof(buf) - len, "%20s : %10u\n",
 431                         "Queued count", priv->tx.queued_cnt);
 432        spin_unlock_bh(&priv->tx.tx_lock);
 433
 434        if (len > sizeof(buf))
 435                len = sizeof(buf);
 436
 437        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 438
 439}
 440
 441static const struct file_operations fops_queue = {
 442        .read = read_file_queue,
 443        .open = simple_open,
 444        .owner = THIS_MODULE,
 445        .llseek = default_llseek,
 446};
 447
 448static ssize_t read_file_debug(struct file *file, char __user *user_buf,
 449                               size_t count, loff_t *ppos)
 450{
 451        struct ath9k_htc_priv *priv = file->private_data;
 452        struct ath_common *common = ath9k_hw_common(priv->ah);
 453        char buf[32];
 454        unsigned int len;
 455
 456        len = sprintf(buf, "0x%08x\n", common->debug_mask);
 457        return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 458}
 459
 460static ssize_t write_file_debug(struct file *file, const char __user *user_buf,
 461                                size_t count, loff_t *ppos)
 462{
 463        struct ath9k_htc_priv *priv = file->private_data;
 464        struct ath_common *common = ath9k_hw_common(priv->ah);
 465        unsigned long mask;
 466        char buf[32];
 467        ssize_t len;
 468
 469        len = min(count, sizeof(buf) - 1);
 470        if (copy_from_user(buf, user_buf, len))
 471                return -EFAULT;
 472
 473        buf[len] = '\0';
 474        if (kstrtoul(buf, 0, &mask))
 475                return -EINVAL;
 476
 477        common->debug_mask = mask;
 478        return count;
 479}
 480
 481static const struct file_operations fops_debug = {
 482        .read = read_file_debug,
 483        .write = write_file_debug,
 484        .open = simple_open,
 485        .owner = THIS_MODULE,
 486        .llseek = default_llseek,
 487};
 488
 489static ssize_t read_file_base_eeprom(struct file *file, char __user *user_buf,
 490                                     size_t count, loff_t *ppos)
 491{
 492        struct ath9k_htc_priv *priv = file->private_data;
 493        struct ath_common *common = ath9k_hw_common(priv->ah);
 494        struct base_eep_header *pBase = NULL;
 495        unsigned int len = 0, size = 1500;
 496        ssize_t retval = 0;
 497        char *buf;
 498
 499        pBase = ath9k_htc_get_eeprom_base(priv);
 500
 501        if (pBase == NULL) {
 502                ath_err(common, "Unknown EEPROM type\n");
 503                return 0;
 504        }
 505
 506        buf = kzalloc(size, GFP_KERNEL);
 507        if (buf == NULL)
 508                return -ENOMEM;
 509
 510        len += scnprintf(buf + len, size - len,
 511                         "%20s : %10d\n", "Major Version",
 512                         pBase->version >> 12);
 513        len += scnprintf(buf + len, size - len,
 514                         "%20s : %10d\n", "Minor Version",
 515                         pBase->version & 0xFFF);
 516        len += scnprintf(buf + len, size - len,
 517                         "%20s : %10d\n", "Checksum",
 518                         pBase->checksum);
 519        len += scnprintf(buf + len, size - len,
 520                         "%20s : %10d\n", "Length",
 521                         pBase->length);
 522        len += scnprintf(buf + len, size - len,
 523                         "%20s : %10d\n", "RegDomain1",
 524                         pBase->regDmn[0]);
 525        len += scnprintf(buf + len, size - len,
 526                         "%20s : %10d\n", "RegDomain2",
 527                         pBase->regDmn[1]);
 528        len += scnprintf(buf + len, size - len,
 529                         "%20s : %10d\n",
 530                         "TX Mask", pBase->txMask);
 531        len += scnprintf(buf + len, size - len,
 532                         "%20s : %10d\n",
 533                         "RX Mask", pBase->rxMask);
 534        len += scnprintf(buf + len, size - len,
 535                         "%20s : %10d\n",
 536                         "Allow 5GHz",
 537                         !!(pBase->opCapFlags & AR5416_OPFLAGS_11A));
 538        len += scnprintf(buf + len, size - len,
 539                         "%20s : %10d\n",
 540                         "Allow 2GHz",
 541                         !!(pBase->opCapFlags & AR5416_OPFLAGS_11G));
 542        len += scnprintf(buf + len, size - len,
 543                         "%20s : %10d\n",
 544                         "Disable 2GHz HT20",
 545                         !!(pBase->opCapFlags & AR5416_OPFLAGS_N_2G_HT20));
 546        len += scnprintf(buf + len, size - len,
 547                         "%20s : %10d\n",
 548                         "Disable 2GHz HT40",
 549                         !!(pBase->opCapFlags & AR5416_OPFLAGS_N_2G_HT40));
 550        len += scnprintf(buf + len, size - len,
 551                         "%20s : %10d\n",
 552                         "Disable 5Ghz HT20",
 553                         !!(pBase->opCapFlags & AR5416_OPFLAGS_N_5G_HT20));
 554        len += scnprintf(buf + len, size - len,
 555                         "%20s : %10d\n",
 556                         "Disable 5Ghz HT40",
 557                         !!(pBase->opCapFlags & AR5416_OPFLAGS_N_5G_HT40));
 558        len += scnprintf(buf + len, size - len,
 559                         "%20s : %10d\n",
 560                         "Big Endian",
 561                         !!(pBase->eepMisc & 0x01));
 562        len += scnprintf(buf + len, size - len,
 563                         "%20s : %10d\n",
 564                         "Cal Bin Major Ver",
 565                         (pBase->binBuildNumber >> 24) & 0xFF);
 566        len += scnprintf(buf + len, size - len,
 567                         "%20s : %10d\n",
 568                         "Cal Bin Minor Ver",
 569                         (pBase->binBuildNumber >> 16) & 0xFF);
 570        len += scnprintf(buf + len, size - len,
 571                         "%20s : %10d\n",
 572                         "Cal Bin Build",
 573                         (pBase->binBuildNumber >> 8) & 0xFF);
 574
 575        /*
 576         * UB91 specific data.
 577         */
 578        if (AR_SREV_9271(priv->ah)) {
 579                struct base_eep_header_4k *pBase4k =
 580                        &priv->ah->eeprom.map4k.baseEepHeader;
 581
 582                len += scnprintf(buf + len, size - len,
 583                                 "%20s : %10d\n",
 584                                 "TX Gain type",
 585                                 pBase4k->txGainType);
 586        }
 587
 588        /*
 589         * UB95 specific data.
 590         */
 591        if (priv->ah->hw_version.usbdev == AR9287_USB) {
 592                struct base_eep_ar9287_header *pBase9287 =
 593                        &priv->ah->eeprom.map9287.baseEepHeader;
 594
 595                len += scnprintf(buf + len, size - len,
 596                                 "%20s : %10ddB\n",
 597                                 "Power Table Offset",
 598                                 pBase9287->pwrTableOffset);
 599
 600                len += scnprintf(buf + len, size - len,
 601                                 "%20s : %10d\n",
 602                                 "OpenLoop Power Ctrl",
 603                                 pBase9287->openLoopPwrCntl);
 604        }
 605
 606        len += scnprintf(buf + len, size - len, "%20s : %pM\n", "MacAddress",
 607                         pBase->macAddr);
 608        if (len > size)
 609                len = size;
 610
 611        retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 612        kfree(buf);
 613
 614        return retval;
 615}
 616
 617static const struct file_operations fops_base_eeprom = {
 618        .read = read_file_base_eeprom,
 619        .open = simple_open,
 620        .owner = THIS_MODULE,
 621        .llseek = default_llseek,
 622};
 623
 624static ssize_t read_4k_modal_eeprom(struct file *file,
 625                                    char __user *user_buf,
 626                                    size_t count, loff_t *ppos)
 627{
 628#define PR_EEP(_s, _val)                                                \
 629        do {                                                            \
 630                len += scnprintf(buf + len, size - len, "%20s : %10d\n",\
 631                                 _s, (_val));                           \
 632        } while (0)
 633
 634        struct ath9k_htc_priv *priv = file->private_data;
 635        struct modal_eep_4k_header *pModal = &priv->ah->eeprom.map4k.modalHeader;
 636        unsigned int len = 0, size = 2048;
 637        ssize_t retval = 0;
 638        char *buf;
 639
 640        buf = kzalloc(size, GFP_KERNEL);
 641        if (buf == NULL)
 642                return -ENOMEM;
 643
 644        PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]);
 645        PR_EEP("Ant. Common Control", pModal->antCtrlCommon);
 646        PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]);
 647        PR_EEP("Switch Settle", pModal->switchSettling);
 648        PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]);
 649        PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]);
 650        PR_EEP("ADC Desired size", pModal->adcDesiredSize);
 651        PR_EEP("PGA Desired size", pModal->pgaDesiredSize);
 652        PR_EEP("Chain0 xlna Gain", pModal->xlnaGainCh[0]);
 653        PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff);
 654        PR_EEP("txEndToRxOn", pModal->txEndToRxOn);
 655        PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn);
 656        PR_EEP("CCA Threshold)", pModal->thresh62);
 657        PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]);
 658        PR_EEP("xpdGain", pModal->xpdGain);
 659        PR_EEP("External PD", pModal->xpd);
 660        PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]);
 661        PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]);
 662        PR_EEP("pdGainOverlap", pModal->pdGainOverlap);
 663        PR_EEP("O/D Bias Version", pModal->version);
 664        PR_EEP("CCK OutputBias", pModal->ob_0);
 665        PR_EEP("BPSK OutputBias", pModal->ob_1);
 666        PR_EEP("QPSK OutputBias", pModal->ob_2);
 667        PR_EEP("16QAM OutputBias", pModal->ob_3);
 668        PR_EEP("64QAM OutputBias", pModal->ob_4);
 669        PR_EEP("CCK Driver1_Bias", pModal->db1_0);
 670        PR_EEP("BPSK Driver1_Bias", pModal->db1_1);
 671        PR_EEP("QPSK Driver1_Bias", pModal->db1_2);
 672        PR_EEP("16QAM Driver1_Bias", pModal->db1_3);
 673        PR_EEP("64QAM Driver1_Bias", pModal->db1_4);
 674        PR_EEP("CCK Driver2_Bias", pModal->db2_0);
 675        PR_EEP("BPSK Driver2_Bias", pModal->db2_1);
 676        PR_EEP("QPSK Driver2_Bias", pModal->db2_2);
 677        PR_EEP("16QAM Driver2_Bias", pModal->db2_3);
 678        PR_EEP("64QAM Driver2_Bias", pModal->db2_4);
 679        PR_EEP("xPA Bias Level", pModal->xpaBiasLvl);
 680        PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart);
 681        PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn);
 682        PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc);
 683        PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]);
 684        PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]);
 685        PR_EEP("HT40 Switch Settle", pModal->swSettleHt40);
 686        PR_EEP("Chain0 xatten2Db", pModal->xatten2Db[0]);
 687        PR_EEP("Chain0 xatten2Margin", pModal->xatten2Margin[0]);
 688        PR_EEP("Ant. Diversity ctl1", pModal->antdiv_ctl1);
 689        PR_EEP("Ant. Diversity ctl2", pModal->antdiv_ctl2);
 690        PR_EEP("TX Diversity", pModal->tx_diversity);
 691
 692        if (len > size)
 693                len = size;
 694
 695        retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 696        kfree(buf);
 697
 698        return retval;
 699
 700#undef PR_EEP
 701}
 702
 703static ssize_t read_def_modal_eeprom(struct file *file,
 704                                     char __user *user_buf,
 705                                     size_t count, loff_t *ppos)
 706{
 707#define PR_EEP(_s, _val)                                                \
 708        do {                                                            \
 709                if (pBase->opCapFlags & AR5416_OPFLAGS_11G) {           \
 710                        pModal = &priv->ah->eeprom.def.modalHeader[1];  \
 711                        len += scnprintf(buf + len, size - len, "%20s : %8d%7s", \
 712                                         _s, (_val), "|");              \
 713                }                                                       \
 714                if (pBase->opCapFlags & AR5416_OPFLAGS_11A) {           \
 715                        pModal = &priv->ah->eeprom.def.modalHeader[0];  \
 716                        len += scnprintf(buf + len, size - len, "%9d\n",\
 717                                        (_val));                        \
 718                }                                                       \
 719        } while (0)
 720
 721        struct ath9k_htc_priv *priv = file->private_data;
 722        struct base_eep_header *pBase = &priv->ah->eeprom.def.baseEepHeader;
 723        struct modal_eep_header *pModal = NULL;
 724        unsigned int len = 0, size = 3500;
 725        ssize_t retval = 0;
 726        char *buf;
 727
 728        buf = kzalloc(size, GFP_KERNEL);
 729        if (buf == NULL)
 730                return -ENOMEM;
 731
 732        len += scnprintf(buf + len, size - len,
 733                         "%31s %15s\n", "2G", "5G");
 734        len += scnprintf(buf + len, size - len,
 735                         "%32s %16s\n", "====", "====\n");
 736
 737        PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]);
 738        PR_EEP("Chain1 Ant. Control", pModal->antCtrlChain[1]);
 739        PR_EEP("Chain2 Ant. Control", pModal->antCtrlChain[2]);
 740        PR_EEP("Ant. Common Control", pModal->antCtrlCommon);
 741        PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]);
 742        PR_EEP("Chain1 Ant. Gain", pModal->antennaGainCh[1]);
 743        PR_EEP("Chain2 Ant. Gain", pModal->antennaGainCh[2]);
 744        PR_EEP("Switch Settle", pModal->switchSettling);
 745        PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]);
 746        PR_EEP("Chain1 TxRxAtten", pModal->txRxAttenCh[1]);
 747        PR_EEP("Chain2 TxRxAtten", pModal->txRxAttenCh[2]);
 748        PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]);
 749        PR_EEP("Chain1 RxTxMargin", pModal->rxTxMarginCh[1]);
 750        PR_EEP("Chain2 RxTxMargin", pModal->rxTxMarginCh[2]);
 751        PR_EEP("ADC Desired size", pModal->adcDesiredSize);
 752        PR_EEP("PGA Desired size", pModal->pgaDesiredSize);
 753        PR_EEP("Chain0 xlna Gain", pModal->xlnaGainCh[0]);
 754        PR_EEP("Chain1 xlna Gain", pModal->xlnaGainCh[1]);
 755        PR_EEP("Chain2 xlna Gain", pModal->xlnaGainCh[2]);
 756        PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff);
 757        PR_EEP("txEndToRxOn", pModal->txEndToRxOn);
 758        PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn);
 759        PR_EEP("CCA Threshold)", pModal->thresh62);
 760        PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]);
 761        PR_EEP("Chain1 NF Threshold", pModal->noiseFloorThreshCh[1]);
 762        PR_EEP("Chain2 NF Threshold", pModal->noiseFloorThreshCh[2]);
 763        PR_EEP("xpdGain", pModal->xpdGain);
 764        PR_EEP("External PD", pModal->xpd);
 765        PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]);
 766        PR_EEP("Chain1 I Coefficient", pModal->iqCalICh[1]);
 767        PR_EEP("Chain2 I Coefficient", pModal->iqCalICh[2]);
 768        PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]);
 769        PR_EEP("Chain1 Q Coefficient", pModal->iqCalQCh[1]);
 770        PR_EEP("Chain2 Q Coefficient", pModal->iqCalQCh[2]);
 771        PR_EEP("pdGainOverlap", pModal->pdGainOverlap);
 772        PR_EEP("Chain0 OutputBias", pModal->ob);
 773        PR_EEP("Chain0 DriverBias", pModal->db);
 774        PR_EEP("xPA Bias Level", pModal->xpaBiasLvl);
 775        PR_EEP("2chain pwr decrease", pModal->pwrDecreaseFor2Chain);
 776        PR_EEP("3chain pwr decrease", pModal->pwrDecreaseFor3Chain);
 777        PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart);
 778        PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn);
 779        PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc);
 780        PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]);
 781        PR_EEP("Chain1 bswAtten", pModal->bswAtten[1]);
 782        PR_EEP("Chain2 bswAtten", pModal->bswAtten[2]);
 783        PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]);
 784        PR_EEP("Chain1 bswMargin", pModal->bswMargin[1]);
 785        PR_EEP("Chain2 bswMargin", pModal->bswMargin[2]);
 786        PR_EEP("HT40 Switch Settle", pModal->swSettleHt40);
 787        PR_EEP("Chain0 xatten2Db", pModal->xatten2Db[0]);
 788        PR_EEP("Chain1 xatten2Db", pModal->xatten2Db[1]);
 789        PR_EEP("Chain2 xatten2Db", pModal->xatten2Db[2]);
 790        PR_EEP("Chain0 xatten2Margin", pModal->xatten2Margin[0]);
 791        PR_EEP("Chain1 xatten2Margin", pModal->xatten2Margin[1]);
 792        PR_EEP("Chain2 xatten2Margin", pModal->xatten2Margin[2]);
 793        PR_EEP("Chain1 OutputBias", pModal->ob_ch1);
 794        PR_EEP("Chain1 DriverBias", pModal->db_ch1);
 795        PR_EEP("LNA Control", pModal->lna_ctl);
 796        PR_EEP("XPA Bias Freq0", pModal->xpaBiasLvlFreq[0]);
 797        PR_EEP("XPA Bias Freq1", pModal->xpaBiasLvlFreq[1]);
 798        PR_EEP("XPA Bias Freq2", pModal->xpaBiasLvlFreq[2]);
 799
 800        if (len > size)
 801                len = size;
 802
 803        retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 804        kfree(buf);
 805
 806        return retval;
 807
 808#undef PR_EEP
 809}
 810
 811static ssize_t read_9287_modal_eeprom(struct file *file,
 812                                      char __user *user_buf,
 813                                      size_t count, loff_t *ppos)
 814{
 815#define PR_EEP(_s, _val)                                                \
 816        do {                                                            \
 817                len += scnprintf(buf + len, size - len, "%20s : %10d\n",\
 818                                 _s, (_val));                           \
 819        } while (0)
 820
 821        struct ath9k_htc_priv *priv = file->private_data;
 822        struct modal_eep_ar9287_header *pModal = &priv->ah->eeprom.map9287.modalHeader;
 823        unsigned int len = 0, size = 3000;
 824        ssize_t retval = 0;
 825        char *buf;
 826
 827        buf = kzalloc(size, GFP_KERNEL);
 828        if (buf == NULL)
 829                return -ENOMEM;
 830
 831        PR_EEP("Chain0 Ant. Control", pModal->antCtrlChain[0]);
 832        PR_EEP("Chain1 Ant. Control", pModal->antCtrlChain[1]);
 833        PR_EEP("Ant. Common Control", pModal->antCtrlCommon);
 834        PR_EEP("Chain0 Ant. Gain", pModal->antennaGainCh[0]);
 835        PR_EEP("Chain1 Ant. Gain", pModal->antennaGainCh[1]);
 836        PR_EEP("Switch Settle", pModal->switchSettling);
 837        PR_EEP("Chain0 TxRxAtten", pModal->txRxAttenCh[0]);
 838        PR_EEP("Chain1 TxRxAtten", pModal->txRxAttenCh[1]);
 839        PR_EEP("Chain0 RxTxMargin", pModal->rxTxMarginCh[0]);
 840        PR_EEP("Chain1 RxTxMargin", pModal->rxTxMarginCh[1]);
 841        PR_EEP("ADC Desired size", pModal->adcDesiredSize);
 842        PR_EEP("txEndToXpaOff", pModal->txEndToXpaOff);
 843        PR_EEP("txEndToRxOn", pModal->txEndToRxOn);
 844        PR_EEP("txFrameToXpaOn", pModal->txFrameToXpaOn);
 845        PR_EEP("CCA Threshold)", pModal->thresh62);
 846        PR_EEP("Chain0 NF Threshold", pModal->noiseFloorThreshCh[0]);
 847        PR_EEP("Chain1 NF Threshold", pModal->noiseFloorThreshCh[1]);
 848        PR_EEP("xpdGain", pModal->xpdGain);
 849        PR_EEP("External PD", pModal->xpd);
 850        PR_EEP("Chain0 I Coefficient", pModal->iqCalICh[0]);
 851        PR_EEP("Chain1 I Coefficient", pModal->iqCalICh[1]);
 852        PR_EEP("Chain0 Q Coefficient", pModal->iqCalQCh[0]);
 853        PR_EEP("Chain1 Q Coefficient", pModal->iqCalQCh[1]);
 854        PR_EEP("pdGainOverlap", pModal->pdGainOverlap);
 855        PR_EEP("xPA Bias Level", pModal->xpaBiasLvl);
 856        PR_EEP("txFrameToDataStart", pModal->txFrameToDataStart);
 857        PR_EEP("txFrameToPaOn", pModal->txFrameToPaOn);
 858        PR_EEP("HT40 Power Inc.", pModal->ht40PowerIncForPdadc);
 859        PR_EEP("Chain0 bswAtten", pModal->bswAtten[0]);
 860        PR_EEP("Chain1 bswAtten", pModal->bswAtten[1]);
 861        PR_EEP("Chain0 bswMargin", pModal->bswMargin[0]);
 862        PR_EEP("Chain1 bswMargin", pModal->bswMargin[1]);
 863        PR_EEP("HT40 Switch Settle", pModal->swSettleHt40);
 864        PR_EEP("AR92x7 Version", pModal->version);
 865        PR_EEP("DriverBias1", pModal->db1);
 866        PR_EEP("DriverBias2", pModal->db1);
 867        PR_EEP("CCK OutputBias", pModal->ob_cck);
 868        PR_EEP("PSK OutputBias", pModal->ob_psk);
 869        PR_EEP("QAM OutputBias", pModal->ob_qam);
 870        PR_EEP("PAL_OFF OutputBias", pModal->ob_pal_off);
 871
 872        if (len > size)
 873                len = size;
 874
 875        retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 876        kfree(buf);
 877
 878        return retval;
 879
 880#undef PR_EEP
 881}
 882
 883static ssize_t read_file_modal_eeprom(struct file *file, char __user *user_buf,
 884                                      size_t count, loff_t *ppos)
 885{
 886        struct ath9k_htc_priv *priv = file->private_data;
 887
 888        if (AR_SREV_9271(priv->ah))
 889                return read_4k_modal_eeprom(file, user_buf, count, ppos);
 890        else if (priv->ah->hw_version.usbdev == AR9280_USB)
 891                return read_def_modal_eeprom(file, user_buf, count, ppos);
 892        else if (priv->ah->hw_version.usbdev == AR9287_USB)
 893                return read_9287_modal_eeprom(file, user_buf, count, ppos);
 894
 895        return 0;
 896}
 897
 898static const struct file_operations fops_modal_eeprom = {
 899        .read = read_file_modal_eeprom,
 900        .open = simple_open,
 901        .owner = THIS_MODULE,
 902        .llseek = default_llseek,
 903};
 904
 905
 906/* Ethtool support for get-stats */
 907#define AMKSTR(nm) #nm "_BE", #nm "_BK", #nm "_VI", #nm "_VO"
 908static const char ath9k_htc_gstrings_stats[][ETH_GSTRING_LEN] = {
 909        "tx_pkts_nic",
 910        "tx_bytes_nic",
 911        "rx_pkts_nic",
 912        "rx_bytes_nic",
 913
 914        AMKSTR(d_tx_pkts),
 915
 916        "d_rx_crc_err",
 917        "d_rx_decrypt_crc_err",
 918        "d_rx_phy_err",
 919        "d_rx_mic_err",
 920        "d_rx_pre_delim_crc_err",
 921        "d_rx_post_delim_crc_err",
 922        "d_rx_decrypt_busy_err",
 923
 924        "d_rx_phyerr_radar",
 925        "d_rx_phyerr_ofdm_timing",
 926        "d_rx_phyerr_cck_timing",
 927
 928};
 929#define ATH9K_HTC_SSTATS_LEN ARRAY_SIZE(ath9k_htc_gstrings_stats)
 930
 931void ath9k_htc_get_et_strings(struct ieee80211_hw *hw,
 932                              struct ieee80211_vif *vif,
 933                              u32 sset, u8 *data)
 934{
 935        if (sset == ETH_SS_STATS)
 936                memcpy(data, *ath9k_htc_gstrings_stats,
 937                       sizeof(ath9k_htc_gstrings_stats));
 938}
 939
 940int ath9k_htc_get_et_sset_count(struct ieee80211_hw *hw,
 941                                struct ieee80211_vif *vif, int sset)
 942{
 943        if (sset == ETH_SS_STATS)
 944                return ATH9K_HTC_SSTATS_LEN;
 945        return 0;
 946}
 947
 948#define STXBASE priv->debug.tx_stats
 949#define SRXBASE priv->debug.rx_stats
 950#define ASTXQ(a)                                        \
 951        data[i++] = STXBASE.a[IEEE80211_AC_BE];         \
 952        data[i++] = STXBASE.a[IEEE80211_AC_BK];         \
 953        data[i++] = STXBASE.a[IEEE80211_AC_VI];         \
 954        data[i++] = STXBASE.a[IEEE80211_AC_VO]
 955
 956void ath9k_htc_get_et_stats(struct ieee80211_hw *hw,
 957                            struct ieee80211_vif *vif,
 958                            struct ethtool_stats *stats, u64 *data)
 959{
 960        struct ath9k_htc_priv *priv = hw->priv;
 961        int i = 0;
 962
 963        data[i++] = STXBASE.skb_success;
 964        data[i++] = STXBASE.skb_success_bytes;
 965        data[i++] = SRXBASE.skb_completed;
 966        data[i++] = SRXBASE.skb_completed_bytes;
 967
 968        ASTXQ(queue_stats);
 969
 970        data[i++] = SRXBASE.err_crc;
 971        data[i++] = SRXBASE.err_decrypt_crc;
 972        data[i++] = SRXBASE.err_phy;
 973        data[i++] = SRXBASE.err_mic;
 974        data[i++] = SRXBASE.err_pre_delim;
 975        data[i++] = SRXBASE.err_post_delim;
 976        data[i++] = SRXBASE.err_decrypt_busy;
 977
 978        data[i++] = SRXBASE.err_phy_stats[ATH9K_PHYERR_RADAR];
 979        data[i++] = SRXBASE.err_phy_stats[ATH9K_PHYERR_OFDM_TIMING];
 980        data[i++] = SRXBASE.err_phy_stats[ATH9K_PHYERR_CCK_TIMING];
 981
 982        WARN_ON(i != ATH9K_HTC_SSTATS_LEN);
 983}
 984
 985
 986int ath9k_htc_init_debug(struct ath_hw *ah)
 987{
 988        struct ath_common *common = ath9k_hw_common(ah);
 989        struct ath9k_htc_priv *priv = (struct ath9k_htc_priv *) common->priv;
 990
 991        priv->debug.debugfs_phy = debugfs_create_dir(KBUILD_MODNAME,
 992                                             priv->hw->wiphy->debugfsdir);
 993        if (!priv->debug.debugfs_phy)
 994                return -ENOMEM;
 995
 996        debugfs_create_file("tgt_int_stats", S_IRUSR, priv->debug.debugfs_phy,
 997                            priv, &fops_tgt_int_stats);
 998        debugfs_create_file("tgt_tx_stats", S_IRUSR, priv->debug.debugfs_phy,
 999                            priv, &fops_tgt_tx_stats);
1000        debugfs_create_file("tgt_rx_stats", S_IRUSR, priv->debug.debugfs_phy,
1001                            priv, &fops_tgt_rx_stats);
1002        debugfs_create_file("xmit", S_IRUSR, priv->debug.debugfs_phy,
1003                            priv, &fops_xmit);
1004        debugfs_create_file("recv", S_IRUSR, priv->debug.debugfs_phy,
1005                            priv, &fops_recv);
1006        debugfs_create_file("slot", S_IRUSR, priv->debug.debugfs_phy,
1007                            priv, &fops_slot);
1008        debugfs_create_file("queue", S_IRUSR, priv->debug.debugfs_phy,
1009                            priv, &fops_queue);
1010        debugfs_create_file("debug", S_IRUSR | S_IWUSR, priv->debug.debugfs_phy,
1011                            priv, &fops_debug);
1012        debugfs_create_file("base_eeprom", S_IRUSR, priv->debug.debugfs_phy,
1013                            priv, &fops_base_eeprom);
1014        debugfs_create_file("modal_eeprom", S_IRUSR, priv->debug.debugfs_phy,
1015                            priv, &fops_modal_eeprom);
1016
1017        return 0;
1018}
1019