1 /* 2 * Copyright (c) 2008-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 <linux/slab.h> 18 #include <linux/vmalloc.h> 19 #include <linux/export.h> 20 #include <asm/unaligned.h> 21 22 #include "ath9k.h" 23 24 #define REG_WRITE_D(_ah, _reg, _val) \ 25 ath9k_hw_common(_ah)->ops->write((_ah), (_val), (_reg)) 26 #define REG_READ_D(_ah, _reg) \ 27 ath9k_hw_common(_ah)->ops->read((_ah), (_reg)) 28 29 void ath9k_debug_sync_cause(struct ath_softc *sc, u32 sync_cause) 30 { 31 if (sync_cause) 32 sc->debug.stats.istats.sync_cause_all++; 33 if (sync_cause & AR_INTR_SYNC_RTC_IRQ) 34 sc->debug.stats.istats.sync_rtc_irq++; 35 if (sync_cause & AR_INTR_SYNC_MAC_IRQ) 36 sc->debug.stats.istats.sync_mac_irq++; 37 if (sync_cause & AR_INTR_SYNC_EEPROM_ILLEGAL_ACCESS) 38 sc->debug.stats.istats.eeprom_illegal_access++; 39 if (sync_cause & AR_INTR_SYNC_APB_TIMEOUT) 40 sc->debug.stats.istats.apb_timeout++; 41 if (sync_cause & AR_INTR_SYNC_PCI_MODE_CONFLICT) 42 sc->debug.stats.istats.pci_mode_conflict++; 43 if (sync_cause & AR_INTR_SYNC_HOST1_FATAL) 44 sc->debug.stats.istats.host1_fatal++; 45 if (sync_cause & AR_INTR_SYNC_HOST1_PERR) 46 sc->debug.stats.istats.host1_perr++; 47 if (sync_cause & AR_INTR_SYNC_TRCV_FIFO_PERR) 48 sc->debug.stats.istats.trcv_fifo_perr++; 49 if (sync_cause & AR_INTR_SYNC_RADM_CPL_EP) 50 sc->debug.stats.istats.radm_cpl_ep++; 51 if (sync_cause & AR_INTR_SYNC_RADM_CPL_DLLP_ABORT) 52 sc->debug.stats.istats.radm_cpl_dllp_abort++; 53 if (sync_cause & AR_INTR_SYNC_RADM_CPL_TLP_ABORT) 54 sc->debug.stats.istats.radm_cpl_tlp_abort++; 55 if (sync_cause & AR_INTR_SYNC_RADM_CPL_ECRC_ERR) 56 sc->debug.stats.istats.radm_cpl_ecrc_err++; 57 if (sync_cause & AR_INTR_SYNC_RADM_CPL_TIMEOUT) 58 sc->debug.stats.istats.radm_cpl_timeout++; 59 if (sync_cause & AR_INTR_SYNC_LOCAL_TIMEOUT) 60 sc->debug.stats.istats.local_timeout++; 61 if (sync_cause & AR_INTR_SYNC_PM_ACCESS) 62 sc->debug.stats.istats.pm_access++; 63 if (sync_cause & AR_INTR_SYNC_MAC_AWAKE) 64 sc->debug.stats.istats.mac_awake++; 65 if (sync_cause & AR_INTR_SYNC_MAC_ASLEEP) 66 sc->debug.stats.istats.mac_asleep++; 67 if (sync_cause & AR_INTR_SYNC_MAC_SLEEP_ACCESS) 68 sc->debug.stats.istats.mac_sleep_access++; 69 } 70 71 static ssize_t ath9k_debugfs_read_buf(struct file *file, char __user *user_buf, 72 size_t count, loff_t *ppos) 73 { 74 u8 *buf = file->private_data; 75 return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf)); 76 } 77 78 static int ath9k_debugfs_release_buf(struct inode *inode, struct file *file) 79 { 80 vfree(file->private_data); 81 return 0; 82 } 83 84 #ifdef CONFIG_ATH_DEBUG 85 86 static ssize_t read_file_debug(struct file *file, char __user *user_buf, 87 size_t count, loff_t *ppos) 88 { 89 struct ath_softc *sc = file->private_data; 90 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 91 char buf[32]; 92 unsigned int len; 93 94 len = sprintf(buf, "0x%08x\n", common->debug_mask); 95 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 96 } 97 98 static ssize_t write_file_debug(struct file *file, const char __user *user_buf, 99 size_t count, loff_t *ppos) 100 { 101 struct ath_softc *sc = file->private_data; 102 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 103 unsigned long mask; 104 char buf[32]; 105 ssize_t len; 106 107 len = min(count, sizeof(buf) - 1); 108 if (copy_from_user(buf, user_buf, len)) 109 return -EFAULT; 110 111 buf[len] = '\0'; 112 if (kstrtoul(buf, 0, &mask)) 113 return -EINVAL; 114 115 common->debug_mask = mask; 116 return count; 117 } 118 119 static const struct file_operations fops_debug = { 120 .read = read_file_debug, 121 .write = write_file_debug, 122 .open = simple_open, 123 .owner = THIS_MODULE, 124 .llseek = default_llseek, 125 }; 126 127 #endif 128 129 #define DMA_BUF_LEN 1024 130 131 132 static ssize_t read_file_ani(struct file *file, char __user *user_buf, 133 size_t count, loff_t *ppos) 134 { 135 struct ath_softc *sc = file->private_data; 136 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 137 struct ath_hw *ah = sc->sc_ah; 138 unsigned int len = 0, size = 1024; 139 ssize_t retval = 0; 140 char *buf; 141 142 buf = kzalloc(size, GFP_KERNEL); 143 if (buf == NULL) 144 return -ENOMEM; 145 146 if (common->disable_ani) { 147 len += scnprintf(buf + len, size - len, "%s: %s\n", 148 "ANI", "DISABLED"); 149 goto exit; 150 } 151 152 len += scnprintf(buf + len, size - len, "%15s: %s\n", 153 "ANI", "ENABLED"); 154 len += scnprintf(buf + len, size - len, "%15s: %u\n", 155 "ANI RESET", ah->stats.ast_ani_reset); 156 len += scnprintf(buf + len, size - len, "%15s: %u\n", 157 "SPUR UP", ah->stats.ast_ani_spurup); 158 len += scnprintf(buf + len, size - len, "%15s: %u\n", 159 "SPUR DOWN", ah->stats.ast_ani_spurup); 160 len += scnprintf(buf + len, size - len, "%15s: %u\n", 161 "OFDM WS-DET ON", ah->stats.ast_ani_ofdmon); 162 len += scnprintf(buf + len, size - len, "%15s: %u\n", 163 "OFDM WS-DET OFF", ah->stats.ast_ani_ofdmoff); 164 len += scnprintf(buf + len, size - len, "%15s: %u\n", 165 "MRC-CCK ON", ah->stats.ast_ani_ccklow); 166 len += scnprintf(buf + len, size - len, "%15s: %u\n", 167 "MRC-CCK OFF", ah->stats.ast_ani_cckhigh); 168 len += scnprintf(buf + len, size - len, "%15s: %u\n", 169 "FIR-STEP UP", ah->stats.ast_ani_stepup); 170 len += scnprintf(buf + len, size - len, "%15s: %u\n", 171 "FIR-STEP DOWN", ah->stats.ast_ani_stepdown); 172 len += scnprintf(buf + len, size - len, "%15s: %u\n", 173 "INV LISTENTIME", ah->stats.ast_ani_lneg_or_lzero); 174 len += scnprintf(buf + len, size - len, "%15s: %u\n", 175 "OFDM ERRORS", ah->stats.ast_ani_ofdmerrs); 176 len += scnprintf(buf + len, size - len, "%15s: %u\n", 177 "CCK ERRORS", ah->stats.ast_ani_cckerrs); 178 exit: 179 if (len > size) 180 len = size; 181 182 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 183 kfree(buf); 184 185 return retval; 186 } 187 188 static ssize_t write_file_ani(struct file *file, 189 const char __user *user_buf, 190 size_t count, loff_t *ppos) 191 { 192 struct ath_softc *sc = file->private_data; 193 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 194 unsigned long ani; 195 char buf[32]; 196 ssize_t len; 197 198 len = min(count, sizeof(buf) - 1); 199 if (copy_from_user(buf, user_buf, len)) 200 return -EFAULT; 201 202 buf[len] = '\0'; 203 if (kstrtoul(buf, 0, &ani)) 204 return -EINVAL; 205 206 if (ani < 0 || ani > 1) 207 return -EINVAL; 208 209 common->disable_ani = !ani; 210 211 if (common->disable_ani) { 212 clear_bit(SC_OP_ANI_RUN, &sc->sc_flags); 213 ath_stop_ani(sc); 214 } else { 215 ath_check_ani(sc); 216 } 217 218 return count; 219 } 220 221 static const struct file_operations fops_ani = { 222 .read = read_file_ani, 223 .write = write_file_ani, 224 .open = simple_open, 225 .owner = THIS_MODULE, 226 .llseek = default_llseek, 227 }; 228 229 #ifdef CONFIG_ATH9K_BTCOEX_SUPPORT 230 231 static ssize_t read_file_bt_ant_diversity(struct file *file, 232 char __user *user_buf, 233 size_t count, loff_t *ppos) 234 { 235 struct ath_softc *sc = file->private_data; 236 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 237 char buf[32]; 238 unsigned int len; 239 240 len = sprintf(buf, "%d\n", common->bt_ant_diversity); 241 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 242 } 243 244 static ssize_t write_file_bt_ant_diversity(struct file *file, 245 const char __user *user_buf, 246 size_t count, loff_t *ppos) 247 { 248 struct ath_softc *sc = file->private_data; 249 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 250 struct ath9k_hw_capabilities *pCap = &sc->sc_ah->caps; 251 unsigned long bt_ant_diversity; 252 char buf[32]; 253 ssize_t len; 254 255 len = min(count, sizeof(buf) - 1); 256 if (copy_from_user(buf, user_buf, len)) 257 return -EFAULT; 258 259 if (!(pCap->hw_caps & ATH9K_HW_CAP_BT_ANT_DIV)) 260 goto exit; 261 262 buf[len] = '\0'; 263 if (kstrtoul(buf, 0, &bt_ant_diversity)) 264 return -EINVAL; 265 266 common->bt_ant_diversity = !!bt_ant_diversity; 267 ath9k_ps_wakeup(sc); 268 ath9k_hw_set_bt_ant_diversity(sc->sc_ah, common->bt_ant_diversity); 269 ath_dbg(common, CONFIG, "Enable WLAN/BT RX Antenna diversity: %d\n", 270 common->bt_ant_diversity); 271 ath9k_ps_restore(sc); 272 exit: 273 return count; 274 } 275 276 static const struct file_operations fops_bt_ant_diversity = { 277 .read = read_file_bt_ant_diversity, 278 .write = write_file_bt_ant_diversity, 279 .open = simple_open, 280 .owner = THIS_MODULE, 281 .llseek = default_llseek, 282 }; 283 284 #endif 285 286 void ath9k_debug_stat_ant(struct ath_softc *sc, 287 struct ath_hw_antcomb_conf *div_ant_conf, 288 int main_rssi_avg, int alt_rssi_avg) 289 { 290 struct ath_antenna_stats *as_main = &sc->debug.stats.ant_stats[ANT_MAIN]; 291 struct ath_antenna_stats *as_alt = &sc->debug.stats.ant_stats[ANT_ALT]; 292 293 as_main->lna_attempt_cnt[div_ant_conf->main_lna_conf]++; 294 as_alt->lna_attempt_cnt[div_ant_conf->alt_lna_conf]++; 295 296 as_main->rssi_avg = main_rssi_avg; 297 as_alt->rssi_avg = alt_rssi_avg; 298 } 299 300 static ssize_t read_file_antenna_diversity(struct file *file, 301 char __user *user_buf, 302 size_t count, loff_t *ppos) 303 { 304 struct ath_softc *sc = file->private_data; 305 struct ath_hw *ah = sc->sc_ah; 306 struct ath9k_hw_capabilities *pCap = &ah->caps; 307 struct ath_antenna_stats *as_main = &sc->debug.stats.ant_stats[ANT_MAIN]; 308 struct ath_antenna_stats *as_alt = &sc->debug.stats.ant_stats[ANT_ALT]; 309 struct ath_hw_antcomb_conf div_ant_conf; 310 unsigned int len = 0, size = 1024; 311 ssize_t retval = 0; 312 char *buf; 313 char *lna_conf_str[4] = {"LNA1_MINUS_LNA2", 314 "LNA2", 315 "LNA1", 316 "LNA1_PLUS_LNA2"}; 317 318 buf = kzalloc(size, GFP_KERNEL); 319 if (buf == NULL) 320 return -ENOMEM; 321 322 if (!(pCap->hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB)) { 323 len += scnprintf(buf + len, size - len, "%s\n", 324 "Antenna Diversity Combining is disabled"); 325 goto exit; 326 } 327 328 ath9k_ps_wakeup(sc); 329 ath9k_hw_antdiv_comb_conf_get(ah, &div_ant_conf); 330 len += scnprintf(buf + len, size - len, "Current MAIN config : %s\n", 331 lna_conf_str[div_ant_conf.main_lna_conf]); 332 len += scnprintf(buf + len, size - len, "Current ALT config : %s\n", 333 lna_conf_str[div_ant_conf.alt_lna_conf]); 334 len += scnprintf(buf + len, size - len, "Average MAIN RSSI : %d\n", 335 as_main->rssi_avg); 336 len += scnprintf(buf + len, size - len, "Average ALT RSSI : %d\n\n", 337 as_alt->rssi_avg); 338 ath9k_ps_restore(sc); 339 340 len += scnprintf(buf + len, size - len, "Packet Receive Cnt:\n"); 341 len += scnprintf(buf + len, size - len, "-------------------\n"); 342 343 len += scnprintf(buf + len, size - len, "%30s%15s\n", 344 "MAIN", "ALT"); 345 len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", 346 "TOTAL COUNT", 347 as_main->recv_cnt, 348 as_alt->recv_cnt); 349 len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", 350 "LNA1", 351 as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1], 352 as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1]); 353 len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", 354 "LNA2", 355 as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA2], 356 as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA2]); 357 len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", 358 "LNA1 + LNA2", 359 as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2], 360 as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2]); 361 len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", 362 "LNA1 - LNA2", 363 as_main->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2], 364 as_alt->lna_recv_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2]); 365 366 len += scnprintf(buf + len, size - len, "\nLNA Config Attempts:\n"); 367 len += scnprintf(buf + len, size - len, "--------------------\n"); 368 369 len += scnprintf(buf + len, size - len, "%30s%15s\n", 370 "MAIN", "ALT"); 371 len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", 372 "LNA1", 373 as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1], 374 as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1]); 375 len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", 376 "LNA2", 377 as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA2], 378 as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA2]); 379 len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", 380 "LNA1 + LNA2", 381 as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2], 382 as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_PLUS_LNA2]); 383 len += scnprintf(buf + len, size - len, "%-14s:%15d%15d\n", 384 "LNA1 - LNA2", 385 as_main->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2], 386 as_alt->lna_attempt_cnt[ATH_ANT_DIV_COMB_LNA1_MINUS_LNA2]); 387 388 exit: 389 if (len > size) 390 len = size; 391 392 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 393 kfree(buf); 394 395 return retval; 396 } 397 398 static const struct file_operations fops_antenna_diversity = { 399 .read = read_file_antenna_diversity, 400 .open = simple_open, 401 .owner = THIS_MODULE, 402 .llseek = default_llseek, 403 }; 404 405 static ssize_t read_file_dma(struct file *file, char __user *user_buf, 406 size_t count, loff_t *ppos) 407 { 408 struct ath_softc *sc = file->private_data; 409 struct ath_hw *ah = sc->sc_ah; 410 char *buf; 411 int retval; 412 unsigned int len = 0; 413 u32 val[ATH9K_NUM_DMA_DEBUG_REGS]; 414 int i, qcuOffset = 0, dcuOffset = 0; 415 u32 *qcuBase = &val[0], *dcuBase = &val[4]; 416 417 buf = kmalloc(DMA_BUF_LEN, GFP_KERNEL); 418 if (!buf) 419 return -ENOMEM; 420 421 ath9k_ps_wakeup(sc); 422 423 REG_WRITE_D(ah, AR_MACMISC, 424 ((AR_MACMISC_DMA_OBS_LINE_8 << AR_MACMISC_DMA_OBS_S) | 425 (AR_MACMISC_MISC_OBS_BUS_1 << 426 AR_MACMISC_MISC_OBS_BUS_MSB_S))); 427 428 len += scnprintf(buf + len, DMA_BUF_LEN - len, 429 "Raw DMA Debug values:\n"); 430 431 for (i = 0; i < ATH9K_NUM_DMA_DEBUG_REGS; i++) { 432 if (i % 4 == 0) 433 len += scnprintf(buf + len, DMA_BUF_LEN - len, "\n"); 434 435 val[i] = REG_READ_D(ah, AR_DMADBG_0 + (i * sizeof(u32))); 436 len += scnprintf(buf + len, DMA_BUF_LEN - len, "%d: %08x ", 437 i, val[i]); 438 } 439 440 len += scnprintf(buf + len, DMA_BUF_LEN - len, "\n\n"); 441 len += scnprintf(buf + len, DMA_BUF_LEN - len, 442 "Num QCU: chain_st fsp_ok fsp_st DCU: chain_st\n"); 443 444 for (i = 0; i < ATH9K_NUM_QUEUES; i++, qcuOffset += 4, dcuOffset += 5) { 445 if (i == 8) { 446 qcuOffset = 0; 447 qcuBase++; 448 } 449 450 if (i == 6) { 451 dcuOffset = 0; 452 dcuBase++; 453 } 454 455 len += scnprintf(buf + len, DMA_BUF_LEN - len, 456 "%2d %2x %1x %2x %2x\n", 457 i, (*qcuBase & (0x7 << qcuOffset)) >> qcuOffset, 458 (*qcuBase & (0x8 << qcuOffset)) >> (qcuOffset + 3), 459 val[2] & (0x7 << (i * 3)) >> (i * 3), 460 (*dcuBase & (0x1f << dcuOffset)) >> dcuOffset); 461 } 462 463 len += scnprintf(buf + len, DMA_BUF_LEN - len, "\n"); 464 465 len += scnprintf(buf + len, DMA_BUF_LEN - len, 466 "qcu_stitch state: %2x qcu_fetch state: %2x\n", 467 (val[3] & 0x003c0000) >> 18, (val[3] & 0x03c00000) >> 22); 468 len += scnprintf(buf + len, DMA_BUF_LEN - len, 469 "qcu_complete state: %2x dcu_complete state: %2x\n", 470 (val[3] & 0x1c000000) >> 26, (val[6] & 0x3)); 471 len += scnprintf(buf + len, DMA_BUF_LEN - len, 472 "dcu_arb state: %2x dcu_fp state: %2x\n", 473 (val[5] & 0x06000000) >> 25, (val[5] & 0x38000000) >> 27); 474 len += scnprintf(buf + len, DMA_BUF_LEN - len, 475 "chan_idle_dur: %3d chan_idle_dur_valid: %1d\n", 476 (val[6] & 0x000003fc) >> 2, (val[6] & 0x00000400) >> 10); 477 len += scnprintf(buf + len, DMA_BUF_LEN - len, 478 "txfifo_valid_0: %1d txfifo_valid_1: %1d\n", 479 (val[6] & 0x00000800) >> 11, (val[6] & 0x00001000) >> 12); 480 len += scnprintf(buf + len, DMA_BUF_LEN - len, 481 "txfifo_dcu_num_0: %2d txfifo_dcu_num_1: %2d\n", 482 (val[6] & 0x0001e000) >> 13, (val[6] & 0x001e0000) >> 17); 483 484 len += scnprintf(buf + len, DMA_BUF_LEN - len, "pcu observe: 0x%x\n", 485 REG_READ_D(ah, AR_OBS_BUS_1)); 486 len += scnprintf(buf + len, DMA_BUF_LEN - len, 487 "AR_CR: 0x%x\n", REG_READ_D(ah, AR_CR)); 488 489 ath9k_ps_restore(sc); 490 491 if (len > DMA_BUF_LEN) 492 len = DMA_BUF_LEN; 493 494 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 495 kfree(buf); 496 return retval; 497 } 498 499 static const struct file_operations fops_dma = { 500 .read = read_file_dma, 501 .open = simple_open, 502 .owner = THIS_MODULE, 503 .llseek = default_llseek, 504 }; 505 506 507 void ath_debug_stat_interrupt(struct ath_softc *sc, enum ath9k_int status) 508 { 509 if (status) 510 sc->debug.stats.istats.total++; 511 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) { 512 if (status & ATH9K_INT_RXLP) 513 sc->debug.stats.istats.rxlp++; 514 if (status & ATH9K_INT_RXHP) 515 sc->debug.stats.istats.rxhp++; 516 if (status & ATH9K_INT_BB_WATCHDOG) 517 sc->debug.stats.istats.bb_watchdog++; 518 } else { 519 if (status & ATH9K_INT_RX) 520 sc->debug.stats.istats.rxok++; 521 } 522 if (status & ATH9K_INT_RXEOL) 523 sc->debug.stats.istats.rxeol++; 524 if (status & ATH9K_INT_RXORN) 525 sc->debug.stats.istats.rxorn++; 526 if (status & ATH9K_INT_TX) 527 sc->debug.stats.istats.txok++; 528 if (status & ATH9K_INT_TXURN) 529 sc->debug.stats.istats.txurn++; 530 if (status & ATH9K_INT_RXPHY) 531 sc->debug.stats.istats.rxphyerr++; 532 if (status & ATH9K_INT_RXKCM) 533 sc->debug.stats.istats.rx_keycache_miss++; 534 if (status & ATH9K_INT_SWBA) 535 sc->debug.stats.istats.swba++; 536 if (status & ATH9K_INT_BMISS) 537 sc->debug.stats.istats.bmiss++; 538 if (status & ATH9K_INT_BNR) 539 sc->debug.stats.istats.bnr++; 540 if (status & ATH9K_INT_CST) 541 sc->debug.stats.istats.cst++; 542 if (status & ATH9K_INT_GTT) 543 sc->debug.stats.istats.gtt++; 544 if (status & ATH9K_INT_TIM) 545 sc->debug.stats.istats.tim++; 546 if (status & ATH9K_INT_CABEND) 547 sc->debug.stats.istats.cabend++; 548 if (status & ATH9K_INT_DTIMSYNC) 549 sc->debug.stats.istats.dtimsync++; 550 if (status & ATH9K_INT_DTIM) 551 sc->debug.stats.istats.dtim++; 552 if (status & ATH9K_INT_TSFOOR) 553 sc->debug.stats.istats.tsfoor++; 554 if (status & ATH9K_INT_MCI) 555 sc->debug.stats.istats.mci++; 556 if (status & ATH9K_INT_GENTIMER) 557 sc->debug.stats.istats.gen_timer++; 558 } 559 560 static ssize_t read_file_interrupt(struct file *file, char __user *user_buf, 561 size_t count, loff_t *ppos) 562 { 563 struct ath_softc *sc = file->private_data; 564 unsigned int len = 0; 565 int rv; 566 int mxlen = 4000; 567 char *buf = kmalloc(mxlen, GFP_KERNEL); 568 if (!buf) 569 return -ENOMEM; 570 571 #define PR_IS(a, s) \ 572 do { \ 573 len += scnprintf(buf + len, mxlen - len, \ 574 "%21s: %10u\n", a, \ 575 sc->debug.stats.istats.s); \ 576 } while (0) 577 578 if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) { 579 PR_IS("RXLP", rxlp); 580 PR_IS("RXHP", rxhp); 581 PR_IS("WATHDOG", bb_watchdog); 582 } else { 583 PR_IS("RX", rxok); 584 } 585 PR_IS("RXEOL", rxeol); 586 PR_IS("RXORN", rxorn); 587 PR_IS("TX", txok); 588 PR_IS("TXURN", txurn); 589 PR_IS("MIB", mib); 590 PR_IS("RXPHY", rxphyerr); 591 PR_IS("RXKCM", rx_keycache_miss); 592 PR_IS("SWBA", swba); 593 PR_IS("BMISS", bmiss); 594 PR_IS("BNR", bnr); 595 PR_IS("CST", cst); 596 PR_IS("GTT", gtt); 597 PR_IS("TIM", tim); 598 PR_IS("CABEND", cabend); 599 PR_IS("DTIMSYNC", dtimsync); 600 PR_IS("DTIM", dtim); 601 PR_IS("TSFOOR", tsfoor); 602 PR_IS("MCI", mci); 603 PR_IS("GENTIMER", gen_timer); 604 PR_IS("TOTAL", total); 605 606 len += scnprintf(buf + len, mxlen - len, 607 "SYNC_CAUSE stats:\n"); 608 609 PR_IS("Sync-All", sync_cause_all); 610 PR_IS("RTC-IRQ", sync_rtc_irq); 611 PR_IS("MAC-IRQ", sync_mac_irq); 612 PR_IS("EEPROM-Illegal-Access", eeprom_illegal_access); 613 PR_IS("APB-Timeout", apb_timeout); 614 PR_IS("PCI-Mode-Conflict", pci_mode_conflict); 615 PR_IS("HOST1-Fatal", host1_fatal); 616 PR_IS("HOST1-Perr", host1_perr); 617 PR_IS("TRCV-FIFO-Perr", trcv_fifo_perr); 618 PR_IS("RADM-CPL-EP", radm_cpl_ep); 619 PR_IS("RADM-CPL-DLLP-Abort", radm_cpl_dllp_abort); 620 PR_IS("RADM-CPL-TLP-Abort", radm_cpl_tlp_abort); 621 PR_IS("RADM-CPL-ECRC-Err", radm_cpl_ecrc_err); 622 PR_IS("RADM-CPL-Timeout", radm_cpl_timeout); 623 PR_IS("Local-Bus-Timeout", local_timeout); 624 PR_IS("PM-Access", pm_access); 625 PR_IS("MAC-Awake", mac_awake); 626 PR_IS("MAC-Asleep", mac_asleep); 627 PR_IS("MAC-Sleep-Access", mac_sleep_access); 628 629 if (len > mxlen) 630 len = mxlen; 631 632 rv = simple_read_from_buffer(user_buf, count, ppos, buf, len); 633 kfree(buf); 634 return rv; 635 } 636 637 static const struct file_operations fops_interrupt = { 638 .read = read_file_interrupt, 639 .open = simple_open, 640 .owner = THIS_MODULE, 641 .llseek = default_llseek, 642 }; 643 644 static ssize_t read_file_xmit(struct file *file, char __user *user_buf, 645 size_t count, loff_t *ppos) 646 { 647 struct ath_softc *sc = file->private_data; 648 char *buf; 649 unsigned int len = 0, size = 2048; 650 ssize_t retval = 0; 651 652 buf = kzalloc(size, GFP_KERNEL); 653 if (buf == NULL) 654 return -ENOMEM; 655 656 len += sprintf(buf, "%30s %10s%10s%10s\n\n", 657 "BE", "BK", "VI", "VO"); 658 659 PR("MPDUs Queued: ", queued); 660 PR("MPDUs Completed: ", completed); 661 PR("MPDUs XRetried: ", xretries); 662 PR("Aggregates: ", a_aggr); 663 PR("AMPDUs Queued HW:", a_queued_hw); 664 PR("AMPDUs Queued SW:", a_queued_sw); 665 PR("AMPDUs Completed:", a_completed); 666 PR("AMPDUs Retried: ", a_retries); 667 PR("AMPDUs XRetried: ", a_xretries); 668 PR("TXERR Filtered: ", txerr_filtered); 669 PR("FIFO Underrun: ", fifo_underrun); 670 PR("TXOP Exceeded: ", xtxop); 671 PR("TXTIMER Expiry: ", timer_exp); 672 PR("DESC CFG Error: ", desc_cfg_err); 673 PR("DATA Underrun: ", data_underrun); 674 PR("DELIM Underrun: ", delim_underrun); 675 PR("TX-Pkts-All: ", tx_pkts_all); 676 PR("TX-Bytes-All: ", tx_bytes_all); 677 PR("HW-put-tx-buf: ", puttxbuf); 678 PR("HW-tx-start: ", txstart); 679 PR("HW-tx-proc-desc: ", txprocdesc); 680 PR("TX-Failed: ", txfailed); 681 682 if (len > size) 683 len = size; 684 685 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 686 kfree(buf); 687 688 return retval; 689 } 690 691 static ssize_t print_queue(struct ath_softc *sc, struct ath_txq *txq, 692 char *buf, ssize_t size) 693 { 694 ssize_t len = 0; 695 696 ath_txq_lock(sc, txq); 697 698 len += scnprintf(buf + len, size - len, "%s: %d ", 699 "qnum", txq->axq_qnum); 700 len += scnprintf(buf + len, size - len, "%s: %2d ", 701 "qdepth", txq->axq_depth); 702 len += scnprintf(buf + len, size - len, "%s: %2d ", 703 "ampdu-depth", txq->axq_ampdu_depth); 704 len += scnprintf(buf + len, size - len, "%s: %3d ", 705 "pending", txq->pending_frames); 706 len += scnprintf(buf + len, size - len, "%s: %d\n", 707 "stopped", txq->stopped); 708 709 ath_txq_unlock(sc, txq); 710 return len; 711 } 712 713 static ssize_t read_file_queues(struct file *file, char __user *user_buf, 714 size_t count, loff_t *ppos) 715 { 716 struct ath_softc *sc = file->private_data; 717 struct ath_txq *txq; 718 char *buf; 719 unsigned int len = 0, size = 1024; 720 ssize_t retval = 0; 721 int i; 722 char *qname[4] = {"VO", "VI", "BE", "BK"}; 723 724 buf = kzalloc(size, GFP_KERNEL); 725 if (buf == NULL) 726 return -ENOMEM; 727 728 for (i = 0; i < IEEE80211_NUM_ACS; i++) { 729 txq = sc->tx.txq_map[i]; 730 len += scnprintf(buf + len, size - len, "(%s): ", qname[i]); 731 len += print_queue(sc, txq, buf + len, size - len); 732 } 733 734 len += scnprintf(buf + len, size - len, "(CAB): "); 735 len += print_queue(sc, sc->beacon.cabq, buf + len, size - len); 736 737 if (len > size) 738 len = size; 739 740 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 741 kfree(buf); 742 743 return retval; 744 } 745 746 static ssize_t read_file_misc(struct file *file, char __user *user_buf, 747 size_t count, loff_t *ppos) 748 { 749 struct ath_softc *sc = file->private_data; 750 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 751 struct ieee80211_hw *hw = sc->hw; 752 struct ath9k_vif_iter_data iter_data; 753 char buf[512]; 754 unsigned int len = 0; 755 ssize_t retval = 0; 756 unsigned int reg; 757 u32 rxfilter; 758 759 len += scnprintf(buf + len, sizeof(buf) - len, 760 "BSSID: %pM\n", common->curbssid); 761 len += scnprintf(buf + len, sizeof(buf) - len, 762 "BSSID-MASK: %pM\n", common->bssidmask); 763 len += scnprintf(buf + len, sizeof(buf) - len, 764 "OPMODE: %s\n", 765 ath_opmode_to_string(sc->sc_ah->opmode)); 766 767 ath9k_ps_wakeup(sc); 768 rxfilter = ath9k_hw_getrxfilter(sc->sc_ah); 769 ath9k_ps_restore(sc); 770 771 len += scnprintf(buf + len, sizeof(buf) - len, 772 "RXFILTER: 0x%x", rxfilter); 773 774 if (rxfilter & ATH9K_RX_FILTER_UCAST) 775 len += scnprintf(buf + len, sizeof(buf) - len, " UCAST"); 776 if (rxfilter & ATH9K_RX_FILTER_MCAST) 777 len += scnprintf(buf + len, sizeof(buf) - len, " MCAST"); 778 if (rxfilter & ATH9K_RX_FILTER_BCAST) 779 len += scnprintf(buf + len, sizeof(buf) - len, " BCAST"); 780 if (rxfilter & ATH9K_RX_FILTER_CONTROL) 781 len += scnprintf(buf + len, sizeof(buf) - len, " CONTROL"); 782 if (rxfilter & ATH9K_RX_FILTER_BEACON) 783 len += scnprintf(buf + len, sizeof(buf) - len, " BEACON"); 784 if (rxfilter & ATH9K_RX_FILTER_PROM) 785 len += scnprintf(buf + len, sizeof(buf) - len, " PROM"); 786 if (rxfilter & ATH9K_RX_FILTER_PROBEREQ) 787 len += scnprintf(buf + len, sizeof(buf) - len, " PROBEREQ"); 788 if (rxfilter & ATH9K_RX_FILTER_PHYERR) 789 len += scnprintf(buf + len, sizeof(buf) - len, " PHYERR"); 790 if (rxfilter & ATH9K_RX_FILTER_MYBEACON) 791 len += scnprintf(buf + len, sizeof(buf) - len, " MYBEACON"); 792 if (rxfilter & ATH9K_RX_FILTER_COMP_BAR) 793 len += scnprintf(buf + len, sizeof(buf) - len, " COMP_BAR"); 794 if (rxfilter & ATH9K_RX_FILTER_PSPOLL) 795 len += scnprintf(buf + len, sizeof(buf) - len, " PSPOLL"); 796 if (rxfilter & ATH9K_RX_FILTER_PHYRADAR) 797 len += scnprintf(buf + len, sizeof(buf) - len, " PHYRADAR"); 798 if (rxfilter & ATH9K_RX_FILTER_MCAST_BCAST_ALL) 799 len += scnprintf(buf + len, sizeof(buf) - len, " MCAST_BCAST_ALL"); 800 if (rxfilter & ATH9K_RX_FILTER_CONTROL_WRAPPER) 801 len += scnprintf(buf + len, sizeof(buf) - len, " CONTROL_WRAPPER"); 802 803 len += scnprintf(buf + len, sizeof(buf) - len, "\n"); 804 805 reg = sc->sc_ah->imask; 806 807 len += scnprintf(buf + len, sizeof(buf) - len, 808 "INTERRUPT-MASK: 0x%x", reg); 809 810 if (reg & ATH9K_INT_SWBA) 811 len += scnprintf(buf + len, sizeof(buf) - len, " SWBA"); 812 if (reg & ATH9K_INT_BMISS) 813 len += scnprintf(buf + len, sizeof(buf) - len, " BMISS"); 814 if (reg & ATH9K_INT_CST) 815 len += scnprintf(buf + len, sizeof(buf) - len, " CST"); 816 if (reg & ATH9K_INT_RX) 817 len += scnprintf(buf + len, sizeof(buf) - len, " RX"); 818 if (reg & ATH9K_INT_RXHP) 819 len += scnprintf(buf + len, sizeof(buf) - len, " RXHP"); 820 if (reg & ATH9K_INT_RXLP) 821 len += scnprintf(buf + len, sizeof(buf) - len, " RXLP"); 822 if (reg & ATH9K_INT_BB_WATCHDOG) 823 len += scnprintf(buf + len, sizeof(buf) - len, " BB_WATCHDOG"); 824 825 len += scnprintf(buf + len, sizeof(buf) - len, "\n"); 826 827 ath9k_calculate_iter_data(hw, NULL, &iter_data); 828 829 len += scnprintf(buf + len, sizeof(buf) - len, 830 "VIF-COUNTS: AP: %i STA: %i MESH: %i WDS: %i" 831 " ADHOC: %i TOTAL: %hi BEACON-VIF: %hi\n", 832 iter_data.naps, iter_data.nstations, iter_data.nmeshes, 833 iter_data.nwds, iter_data.nadhocs, 834 sc->nvifs, sc->nbcnvifs); 835 836 if (len > sizeof(buf)) 837 len = sizeof(buf); 838 839 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 840 return retval; 841 } 842 843 static ssize_t read_file_reset(struct file *file, char __user *user_buf, 844 size_t count, loff_t *ppos) 845 { 846 struct ath_softc *sc = file->private_data; 847 char buf[512]; 848 unsigned int len = 0; 849 850 len += scnprintf(buf + len, sizeof(buf) - len, 851 "%17s: %2d\n", "Baseband Hang", 852 sc->debug.stats.reset[RESET_TYPE_BB_HANG]); 853 len += scnprintf(buf + len, sizeof(buf) - len, 854 "%17s: %2d\n", "Baseband Watchdog", 855 sc->debug.stats.reset[RESET_TYPE_BB_WATCHDOG]); 856 len += scnprintf(buf + len, sizeof(buf) - len, 857 "%17s: %2d\n", "Fatal HW Error", 858 sc->debug.stats.reset[RESET_TYPE_FATAL_INT]); 859 len += scnprintf(buf + len, sizeof(buf) - len, 860 "%17s: %2d\n", "TX HW error", 861 sc->debug.stats.reset[RESET_TYPE_TX_ERROR]); 862 len += scnprintf(buf + len, sizeof(buf) - len, 863 "%17s: %2d\n", "TX Path Hang", 864 sc->debug.stats.reset[RESET_TYPE_TX_HANG]); 865 len += scnprintf(buf + len, sizeof(buf) - len, 866 "%17s: %2d\n", "PLL RX Hang", 867 sc->debug.stats.reset[RESET_TYPE_PLL_HANG]); 868 len += scnprintf(buf + len, sizeof(buf) - len, 869 "%17s: %2d\n", "MCI Reset", 870 sc->debug.stats.reset[RESET_TYPE_MCI]); 871 872 if (len > sizeof(buf)) 873 len = sizeof(buf); 874 875 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 876 } 877 878 void ath_debug_stat_tx(struct ath_softc *sc, struct ath_buf *bf, 879 struct ath_tx_status *ts, struct ath_txq *txq, 880 unsigned int flags) 881 { 882 int qnum = txq->axq_qnum; 883 884 TX_STAT_INC(qnum, tx_pkts_all); 885 sc->debug.stats.txstats[qnum].tx_bytes_all += bf->bf_mpdu->len; 886 887 if (bf_isampdu(bf)) { 888 if (flags & ATH_TX_ERROR) 889 TX_STAT_INC(qnum, a_xretries); 890 else 891 TX_STAT_INC(qnum, a_completed); 892 } else { 893 if (ts->ts_status & ATH9K_TXERR_XRETRY) 894 TX_STAT_INC(qnum, xretries); 895 else 896 TX_STAT_INC(qnum, completed); 897 } 898 899 if (ts->ts_status & ATH9K_TXERR_FILT) 900 TX_STAT_INC(qnum, txerr_filtered); 901 if (ts->ts_status & ATH9K_TXERR_FIFO) 902 TX_STAT_INC(qnum, fifo_underrun); 903 if (ts->ts_status & ATH9K_TXERR_XTXOP) 904 TX_STAT_INC(qnum, xtxop); 905 if (ts->ts_status & ATH9K_TXERR_TIMER_EXPIRED) 906 TX_STAT_INC(qnum, timer_exp); 907 if (ts->ts_flags & ATH9K_TX_DESC_CFG_ERR) 908 TX_STAT_INC(qnum, desc_cfg_err); 909 if (ts->ts_flags & ATH9K_TX_DATA_UNDERRUN) 910 TX_STAT_INC(qnum, data_underrun); 911 if (ts->ts_flags & ATH9K_TX_DELIM_UNDERRUN) 912 TX_STAT_INC(qnum, delim_underrun); 913 } 914 915 static const struct file_operations fops_xmit = { 916 .read = read_file_xmit, 917 .open = simple_open, 918 .owner = THIS_MODULE, 919 .llseek = default_llseek, 920 }; 921 922 static const struct file_operations fops_queues = { 923 .read = read_file_queues, 924 .open = simple_open, 925 .owner = THIS_MODULE, 926 .llseek = default_llseek, 927 }; 928 929 static const struct file_operations fops_misc = { 930 .read = read_file_misc, 931 .open = simple_open, 932 .owner = THIS_MODULE, 933 .llseek = default_llseek, 934 }; 935 936 static const struct file_operations fops_reset = { 937 .read = read_file_reset, 938 .open = simple_open, 939 .owner = THIS_MODULE, 940 .llseek = default_llseek, 941 }; 942 943 static ssize_t read_file_recv(struct file *file, char __user *user_buf, 944 size_t count, loff_t *ppos) 945 { 946 #define PHY_ERR(s, p) \ 947 len += scnprintf(buf + len, size - len, "%22s : %10u\n", s, \ 948 sc->debug.stats.rxstats.phy_err_stats[p]); 949 950 #define RXS_ERR(s, e) \ 951 do { \ 952 len += scnprintf(buf + len, size - len, \ 953 "%22s : %10u\n", s, \ 954 sc->debug.stats.rxstats.e);\ 955 } while (0) 956 957 struct ath_softc *sc = file->private_data; 958 char *buf; 959 unsigned int len = 0, size = 1600; 960 ssize_t retval = 0; 961 962 buf = kzalloc(size, GFP_KERNEL); 963 if (buf == NULL) 964 return -ENOMEM; 965 966 RXS_ERR("CRC ERR", crc_err); 967 RXS_ERR("DECRYPT CRC ERR", decrypt_crc_err); 968 RXS_ERR("PHY ERR", phy_err); 969 RXS_ERR("MIC ERR", mic_err); 970 RXS_ERR("PRE-DELIM CRC ERR", pre_delim_crc_err); 971 RXS_ERR("POST-DELIM CRC ERR", post_delim_crc_err); 972 RXS_ERR("DECRYPT BUSY ERR", decrypt_busy_err); 973 RXS_ERR("RX-LENGTH-ERR", rx_len_err); 974 RXS_ERR("RX-OOM-ERR", rx_oom_err); 975 RXS_ERR("RX-RATE-ERR", rx_rate_err); 976 RXS_ERR("RX-TOO-MANY-FRAGS", rx_too_many_frags_err); 977 978 PHY_ERR("UNDERRUN ERR", ATH9K_PHYERR_UNDERRUN); 979 PHY_ERR("TIMING ERR", ATH9K_PHYERR_TIMING); 980 PHY_ERR("PARITY ERR", ATH9K_PHYERR_PARITY); 981 PHY_ERR("RATE ERR", ATH9K_PHYERR_RATE); 982 PHY_ERR("LENGTH ERR", ATH9K_PHYERR_LENGTH); 983 PHY_ERR("RADAR ERR", ATH9K_PHYERR_RADAR); 984 PHY_ERR("SERVICE ERR", ATH9K_PHYERR_SERVICE); 985 PHY_ERR("TOR ERR", ATH9K_PHYERR_TOR); 986 PHY_ERR("OFDM-TIMING ERR", ATH9K_PHYERR_OFDM_TIMING); 987 PHY_ERR("OFDM-SIGNAL-PARITY ERR", ATH9K_PHYERR_OFDM_SIGNAL_PARITY); 988 PHY_ERR("OFDM-RATE ERR", ATH9K_PHYERR_OFDM_RATE_ILLEGAL); 989 PHY_ERR("OFDM-LENGTH ERR", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL); 990 PHY_ERR("OFDM-POWER-DROP ERR", ATH9K_PHYERR_OFDM_POWER_DROP); 991 PHY_ERR("OFDM-SERVICE ERR", ATH9K_PHYERR_OFDM_SERVICE); 992 PHY_ERR("OFDM-RESTART ERR", ATH9K_PHYERR_OFDM_RESTART); 993 PHY_ERR("FALSE-RADAR-EXT ERR", ATH9K_PHYERR_FALSE_RADAR_EXT); 994 PHY_ERR("CCK-TIMING ERR", ATH9K_PHYERR_CCK_TIMING); 995 PHY_ERR("CCK-HEADER-CRC ERR", ATH9K_PHYERR_CCK_HEADER_CRC); 996 PHY_ERR("CCK-RATE ERR", ATH9K_PHYERR_CCK_RATE_ILLEGAL); 997 PHY_ERR("CCK-SERVICE ERR", ATH9K_PHYERR_CCK_SERVICE); 998 PHY_ERR("CCK-RESTART ERR", ATH9K_PHYERR_CCK_RESTART); 999 PHY_ERR("CCK-LENGTH ERR", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL); 1000 PHY_ERR("CCK-POWER-DROP ERR", ATH9K_PHYERR_CCK_POWER_DROP); 1001 PHY_ERR("HT-CRC ERR", ATH9K_PHYERR_HT_CRC_ERROR); 1002 PHY_ERR("HT-LENGTH ERR", ATH9K_PHYERR_HT_LENGTH_ILLEGAL); 1003 PHY_ERR("HT-RATE ERR", ATH9K_PHYERR_HT_RATE_ILLEGAL); 1004 1005 RXS_ERR("RX-Pkts-All", rx_pkts_all); 1006 RXS_ERR("RX-Bytes-All", rx_bytes_all); 1007 RXS_ERR("RX-Beacons", rx_beacons); 1008 RXS_ERR("RX-Frags", rx_frags); 1009 RXS_ERR("RX-Spectral", rx_spectral); 1010 1011 if (len > size) 1012 len = size; 1013 1014 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 1015 kfree(buf); 1016 1017 return retval; 1018 1019 #undef RXS_ERR 1020 #undef PHY_ERR 1021 } 1022 1023 void ath_debug_stat_rx(struct ath_softc *sc, struct ath_rx_status *rs) 1024 { 1025 #define RX_PHY_ERR_INC(c) sc->debug.stats.rxstats.phy_err_stats[c]++ 1026 1027 RX_STAT_INC(rx_pkts_all); 1028 sc->debug.stats.rxstats.rx_bytes_all += rs->rs_datalen; 1029 1030 if (rs->rs_status & ATH9K_RXERR_CRC) 1031 RX_STAT_INC(crc_err); 1032 if (rs->rs_status & ATH9K_RXERR_DECRYPT) 1033 RX_STAT_INC(decrypt_crc_err); 1034 if (rs->rs_status & ATH9K_RXERR_MIC) 1035 RX_STAT_INC(mic_err); 1036 if (rs->rs_status & ATH9K_RX_DELIM_CRC_PRE) 1037 RX_STAT_INC(pre_delim_crc_err); 1038 if (rs->rs_status & ATH9K_RX_DELIM_CRC_POST) 1039 RX_STAT_INC(post_delim_crc_err); 1040 if (rs->rs_status & ATH9K_RX_DECRYPT_BUSY) 1041 RX_STAT_INC(decrypt_busy_err); 1042 1043 if (rs->rs_status & ATH9K_RXERR_PHY) { 1044 RX_STAT_INC(phy_err); 1045 if (rs->rs_phyerr < ATH9K_PHYERR_MAX) 1046 RX_PHY_ERR_INC(rs->rs_phyerr); 1047 } 1048 1049 #undef RX_PHY_ERR_INC 1050 } 1051 1052 static const struct file_operations fops_recv = { 1053 .read = read_file_recv, 1054 .open = simple_open, 1055 .owner = THIS_MODULE, 1056 .llseek = default_llseek, 1057 }; 1058 1059 static ssize_t read_file_regidx(struct file *file, char __user *user_buf, 1060 size_t count, loff_t *ppos) 1061 { 1062 struct ath_softc *sc = file->private_data; 1063 char buf[32]; 1064 unsigned int len; 1065 1066 len = sprintf(buf, "0x%08x\n", sc->debug.regidx); 1067 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 1068 } 1069 1070 static ssize_t write_file_regidx(struct file *file, const char __user *user_buf, 1071 size_t count, loff_t *ppos) 1072 { 1073 struct ath_softc *sc = file->private_data; 1074 unsigned long regidx; 1075 char buf[32]; 1076 ssize_t len; 1077 1078 len = min(count, sizeof(buf) - 1); 1079 if (copy_from_user(buf, user_buf, len)) 1080 return -EFAULT; 1081 1082 buf[len] = '\0'; 1083 if (kstrtoul(buf, 0, ®idx)) 1084 return -EINVAL; 1085 1086 sc->debug.regidx = regidx; 1087 return count; 1088 } 1089 1090 static const struct file_operations fops_regidx = { 1091 .read = read_file_regidx, 1092 .write = write_file_regidx, 1093 .open = simple_open, 1094 .owner = THIS_MODULE, 1095 .llseek = default_llseek, 1096 }; 1097 1098 static ssize_t read_file_regval(struct file *file, char __user *user_buf, 1099 size_t count, loff_t *ppos) 1100 { 1101 struct ath_softc *sc = file->private_data; 1102 struct ath_hw *ah = sc->sc_ah; 1103 char buf[32]; 1104 unsigned int len; 1105 u32 regval; 1106 1107 ath9k_ps_wakeup(sc); 1108 regval = REG_READ_D(ah, sc->debug.regidx); 1109 ath9k_ps_restore(sc); 1110 len = sprintf(buf, "0x%08x\n", regval); 1111 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 1112 } 1113 1114 static ssize_t write_file_regval(struct file *file, const char __user *user_buf, 1115 size_t count, loff_t *ppos) 1116 { 1117 struct ath_softc *sc = file->private_data; 1118 struct ath_hw *ah = sc->sc_ah; 1119 unsigned long regval; 1120 char buf[32]; 1121 ssize_t len; 1122 1123 len = min(count, sizeof(buf) - 1); 1124 if (copy_from_user(buf, user_buf, len)) 1125 return -EFAULT; 1126 1127 buf[len] = '\0'; 1128 if (kstrtoul(buf, 0, ®val)) 1129 return -EINVAL; 1130 1131 ath9k_ps_wakeup(sc); 1132 REG_WRITE_D(ah, sc->debug.regidx, regval); 1133 ath9k_ps_restore(sc); 1134 return count; 1135 } 1136 1137 static const struct file_operations fops_regval = { 1138 .read = read_file_regval, 1139 .write = write_file_regval, 1140 .open = simple_open, 1141 .owner = THIS_MODULE, 1142 .llseek = default_llseek, 1143 }; 1144 1145 #define REGDUMP_LINE_SIZE 20 1146 1147 static int open_file_regdump(struct inode *inode, struct file *file) 1148 { 1149 struct ath_softc *sc = inode->i_private; 1150 unsigned int len = 0; 1151 u8 *buf; 1152 int i; 1153 unsigned long num_regs, regdump_len, max_reg_offset; 1154 1155 max_reg_offset = AR_SREV_9300_20_OR_LATER(sc->sc_ah) ? 0x16bd4 : 0xb500; 1156 num_regs = max_reg_offset / 4 + 1; 1157 regdump_len = num_regs * REGDUMP_LINE_SIZE + 1; 1158 buf = vmalloc(regdump_len); 1159 if (!buf) 1160 return -ENOMEM; 1161 1162 ath9k_ps_wakeup(sc); 1163 for (i = 0; i < num_regs; i++) 1164 len += scnprintf(buf + len, regdump_len - len, 1165 "0x%06x 0x%08x\n", i << 2, REG_READ(sc->sc_ah, i << 2)); 1166 ath9k_ps_restore(sc); 1167 1168 file->private_data = buf; 1169 1170 return 0; 1171 } 1172 1173 static const struct file_operations fops_regdump = { 1174 .open = open_file_regdump, 1175 .read = ath9k_debugfs_read_buf, 1176 .release = ath9k_debugfs_release_buf, 1177 .owner = THIS_MODULE, 1178 .llseek = default_llseek,/* read accesses f_pos */ 1179 }; 1180 1181 static ssize_t read_file_dump_nfcal(struct file *file, char __user *user_buf, 1182 size_t count, loff_t *ppos) 1183 { 1184 struct ath_softc *sc = file->private_data; 1185 struct ath_hw *ah = sc->sc_ah; 1186 struct ath9k_nfcal_hist *h = sc->caldata.nfCalHist; 1187 struct ath_common *common = ath9k_hw_common(ah); 1188 struct ieee80211_conf *conf = &common->hw->conf; 1189 u32 len = 0, size = 1500; 1190 u32 i, j; 1191 ssize_t retval = 0; 1192 char *buf; 1193 u8 chainmask = (ah->rxchainmask << 3) | ah->rxchainmask; 1194 u8 nread; 1195 1196 buf = kzalloc(size, GFP_KERNEL); 1197 if (!buf) 1198 return -ENOMEM; 1199 1200 len += scnprintf(buf + len, size - len, 1201 "Channel Noise Floor : %d\n", ah->noise); 1202 len += scnprintf(buf + len, size - len, 1203 "Chain | privNF | # Readings | NF Readings\n"); 1204 for (i = 0; i < NUM_NF_READINGS; i++) { 1205 if (!(chainmask & (1 << i)) || 1206 ((i >= AR5416_MAX_CHAINS) && !conf_is_ht40(conf))) 1207 continue; 1208 1209 nread = AR_PHY_CCA_FILTERWINDOW_LENGTH - h[i].invalidNFcount; 1210 len += scnprintf(buf + len, size - len, " %d\t %d\t %d\t\t", 1211 i, h[i].privNF, nread); 1212 for (j = 0; j < nread; j++) 1213 len += scnprintf(buf + len, size - len, 1214 " %d", h[i].nfCalBuffer[j]); 1215 len += scnprintf(buf + len, size - len, "\n"); 1216 } 1217 1218 if (len > size) 1219 len = size; 1220 1221 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 1222 kfree(buf); 1223 1224 return retval; 1225 } 1226 1227 static const struct file_operations fops_dump_nfcal = { 1228 .read = read_file_dump_nfcal, 1229 .open = simple_open, 1230 .owner = THIS_MODULE, 1231 .llseek = default_llseek, 1232 }; 1233 1234 static ssize_t read_file_base_eeprom(struct file *file, char __user *user_buf, 1235 size_t count, loff_t *ppos) 1236 { 1237 struct ath_softc *sc = file->private_data; 1238 struct ath_hw *ah = sc->sc_ah; 1239 u32 len = 0, size = 1500; 1240 ssize_t retval = 0; 1241 char *buf; 1242 1243 buf = kzalloc(size, GFP_KERNEL); 1244 if (!buf) 1245 return -ENOMEM; 1246 1247 len = ah->eep_ops->dump_eeprom(ah, true, buf, len, size); 1248 1249 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 1250 kfree(buf); 1251 1252 return retval; 1253 } 1254 1255 static const struct file_operations fops_base_eeprom = { 1256 .read = read_file_base_eeprom, 1257 .open = simple_open, 1258 .owner = THIS_MODULE, 1259 .llseek = default_llseek, 1260 }; 1261 1262 static ssize_t read_file_modal_eeprom(struct file *file, char __user *user_buf, 1263 size_t count, loff_t *ppos) 1264 { 1265 struct ath_softc *sc = file->private_data; 1266 struct ath_hw *ah = sc->sc_ah; 1267 u32 len = 0, size = 6000; 1268 char *buf; 1269 size_t retval; 1270 1271 buf = kzalloc(size, GFP_KERNEL); 1272 if (buf == NULL) 1273 return -ENOMEM; 1274 1275 len = ah->eep_ops->dump_eeprom(ah, false, buf, len, size); 1276 1277 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 1278 kfree(buf); 1279 1280 return retval; 1281 } 1282 1283 static const struct file_operations fops_modal_eeprom = { 1284 .read = read_file_modal_eeprom, 1285 .open = simple_open, 1286 .owner = THIS_MODULE, 1287 .llseek = default_llseek, 1288 }; 1289 1290 #ifdef CONFIG_ATH9K_BTCOEX_SUPPORT 1291 static ssize_t read_file_btcoex(struct file *file, char __user *user_buf, 1292 size_t count, loff_t *ppos) 1293 { 1294 struct ath_softc *sc = file->private_data; 1295 u32 len = 0, size = 1500; 1296 char *buf; 1297 size_t retval; 1298 1299 buf = kzalloc(size, GFP_KERNEL); 1300 if (buf == NULL) 1301 return -ENOMEM; 1302 1303 if (!sc->sc_ah->common.btcoex_enabled) { 1304 len = scnprintf(buf, size, "%s\n", 1305 "BTCOEX is disabled"); 1306 goto exit; 1307 } 1308 1309 len = ath9k_dump_btcoex(sc, buf, size); 1310 exit: 1311 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 1312 kfree(buf); 1313 1314 return retval; 1315 } 1316 1317 static const struct file_operations fops_btcoex = { 1318 .read = read_file_btcoex, 1319 .open = simple_open, 1320 .owner = THIS_MODULE, 1321 .llseek = default_llseek, 1322 }; 1323 #endif 1324 1325 static ssize_t read_file_node_stat(struct file *file, char __user *user_buf, 1326 size_t count, loff_t *ppos) 1327 { 1328 struct ath_node *an = file->private_data; 1329 struct ath_softc *sc = an->sc; 1330 struct ath_atx_tid *tid; 1331 struct ath_atx_ac *ac; 1332 struct ath_txq *txq; 1333 u32 len = 0, size = 4096; 1334 char *buf; 1335 size_t retval; 1336 int tidno, acno; 1337 1338 buf = kzalloc(size, GFP_KERNEL); 1339 if (buf == NULL) 1340 return -ENOMEM; 1341 1342 if (!an->sta->ht_cap.ht_supported) { 1343 len = scnprintf(buf, size, "%s\n", 1344 "HT not supported"); 1345 goto exit; 1346 } 1347 1348 len = scnprintf(buf, size, "Max-AMPDU: %d\n", 1349 an->maxampdu); 1350 len += scnprintf(buf + len, size - len, "MPDU Density: %d\n\n", 1351 an->mpdudensity); 1352 1353 len += scnprintf(buf + len, size - len, 1354 "%2s%7s\n", "AC", "SCHED"); 1355 1356 for (acno = 0, ac = &an->ac[acno]; 1357 acno < IEEE80211_NUM_ACS; acno++, ac++) { 1358 txq = ac->txq; 1359 ath_txq_lock(sc, txq); 1360 len += scnprintf(buf + len, size - len, 1361 "%2d%7d\n", 1362 acno, ac->sched); 1363 ath_txq_unlock(sc, txq); 1364 } 1365 1366 len += scnprintf(buf + len, size - len, 1367 "\n%3s%11s%10s%10s%10s%10s%9s%6s%8s\n", 1368 "TID", "SEQ_START", "SEQ_NEXT", "BAW_SIZE", 1369 "BAW_HEAD", "BAW_TAIL", "BAR_IDX", "SCHED", "PAUSED"); 1370 1371 for (tidno = 0, tid = &an->tid[tidno]; 1372 tidno < IEEE80211_NUM_TIDS; tidno++, tid++) { 1373 txq = tid->ac->txq; 1374 ath_txq_lock(sc, txq); 1375 len += scnprintf(buf + len, size - len, 1376 "%3d%11d%10d%10d%10d%10d%9d%6d%8d\n", 1377 tid->tidno, tid->seq_start, tid->seq_next, 1378 tid->baw_size, tid->baw_head, tid->baw_tail, 1379 tid->bar_index, tid->sched, tid->paused); 1380 ath_txq_unlock(sc, txq); 1381 } 1382 exit: 1383 retval = simple_read_from_buffer(user_buf, count, ppos, buf, len); 1384 kfree(buf); 1385 1386 return retval; 1387 } 1388 1389 static const struct file_operations fops_node_stat = { 1390 .read = read_file_node_stat, 1391 .open = simple_open, 1392 .owner = THIS_MODULE, 1393 .llseek = default_llseek, 1394 }; 1395 1396 void ath9k_sta_add_debugfs(struct ieee80211_hw *hw, 1397 struct ieee80211_vif *vif, 1398 struct ieee80211_sta *sta, 1399 struct dentry *dir) 1400 { 1401 struct ath_node *an = (struct ath_node *)sta->drv_priv; 1402 debugfs_create_file("node_stat", S_IRUGO, dir, an, &fops_node_stat); 1403 } 1404 1405 /* Ethtool support for get-stats */ 1406 1407 #define AMKSTR(nm) #nm "_BE", #nm "_BK", #nm "_VI", #nm "_VO" 1408 static const char ath9k_gstrings_stats[][ETH_GSTRING_LEN] = { 1409 "tx_pkts_nic", 1410 "tx_bytes_nic", 1411 "rx_pkts_nic", 1412 "rx_bytes_nic", 1413 AMKSTR(d_tx_pkts), 1414 AMKSTR(d_tx_bytes), 1415 AMKSTR(d_tx_mpdus_queued), 1416 AMKSTR(d_tx_mpdus_completed), 1417 AMKSTR(d_tx_mpdu_xretries), 1418 AMKSTR(d_tx_aggregates), 1419 AMKSTR(d_tx_ampdus_queued_hw), 1420 AMKSTR(d_tx_ampdus_queued_sw), 1421 AMKSTR(d_tx_ampdus_completed), 1422 AMKSTR(d_tx_ampdu_retries), 1423 AMKSTR(d_tx_ampdu_xretries), 1424 AMKSTR(d_tx_fifo_underrun), 1425 AMKSTR(d_tx_op_exceeded), 1426 AMKSTR(d_tx_timer_expiry), 1427 AMKSTR(d_tx_desc_cfg_err), 1428 AMKSTR(d_tx_data_underrun), 1429 AMKSTR(d_tx_delim_underrun), 1430 "d_rx_crc_err", 1431 "d_rx_decrypt_crc_err", 1432 "d_rx_phy_err", 1433 "d_rx_mic_err", 1434 "d_rx_pre_delim_crc_err", 1435 "d_rx_post_delim_crc_err", 1436 "d_rx_decrypt_busy_err", 1437 1438 "d_rx_phyerr_radar", 1439 "d_rx_phyerr_ofdm_timing", 1440 "d_rx_phyerr_cck_timing", 1441 1442 }; 1443 #define ATH9K_SSTATS_LEN ARRAY_SIZE(ath9k_gstrings_stats) 1444 1445 void ath9k_get_et_strings(struct ieee80211_hw *hw, 1446 struct ieee80211_vif *vif, 1447 u32 sset, u8 *data) 1448 { 1449 if (sset == ETH_SS_STATS) 1450 memcpy(data, *ath9k_gstrings_stats, 1451 sizeof(ath9k_gstrings_stats)); 1452 } 1453 1454 int ath9k_get_et_sset_count(struct ieee80211_hw *hw, 1455 struct ieee80211_vif *vif, int sset) 1456 { 1457 if (sset == ETH_SS_STATS) 1458 return ATH9K_SSTATS_LEN; 1459 return 0; 1460 } 1461 1462 #define AWDATA(elem) \ 1463 do { \ 1464 data[i++] = sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BE)].elem; \ 1465 data[i++] = sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BK)].elem; \ 1466 data[i++] = sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VI)].elem; \ 1467 data[i++] = sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VO)].elem; \ 1468 } while (0) 1469 1470 #define AWDATA_RX(elem) \ 1471 do { \ 1472 data[i++] = sc->debug.stats.rxstats.elem; \ 1473 } while (0) 1474 1475 void ath9k_get_et_stats(struct ieee80211_hw *hw, 1476 struct ieee80211_vif *vif, 1477 struct ethtool_stats *stats, u64 *data) 1478 { 1479 struct ath_softc *sc = hw->priv; 1480 int i = 0; 1481 1482 data[i++] = (sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BE)].tx_pkts_all + 1483 sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BK)].tx_pkts_all + 1484 sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VI)].tx_pkts_all + 1485 sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VO)].tx_pkts_all); 1486 data[i++] = (sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BE)].tx_bytes_all + 1487 sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_BK)].tx_bytes_all + 1488 sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VI)].tx_bytes_all + 1489 sc->debug.stats.txstats[PR_QNUM(IEEE80211_AC_VO)].tx_bytes_all); 1490 AWDATA_RX(rx_pkts_all); 1491 AWDATA_RX(rx_bytes_all); 1492 1493 AWDATA(tx_pkts_all); 1494 AWDATA(tx_bytes_all); 1495 AWDATA(queued); 1496 AWDATA(completed); 1497 AWDATA(xretries); 1498 AWDATA(a_aggr); 1499 AWDATA(a_queued_hw); 1500 AWDATA(a_queued_sw); 1501 AWDATA(a_completed); 1502 AWDATA(a_retries); 1503 AWDATA(a_xretries); 1504 AWDATA(fifo_underrun); 1505 AWDATA(xtxop); 1506 AWDATA(timer_exp); 1507 AWDATA(desc_cfg_err); 1508 AWDATA(data_underrun); 1509 AWDATA(delim_underrun); 1510 1511 AWDATA_RX(crc_err); 1512 AWDATA_RX(decrypt_crc_err); 1513 AWDATA_RX(phy_err); 1514 AWDATA_RX(mic_err); 1515 AWDATA_RX(pre_delim_crc_err); 1516 AWDATA_RX(post_delim_crc_err); 1517 AWDATA_RX(decrypt_busy_err); 1518 1519 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_RADAR]); 1520 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_OFDM_TIMING]); 1521 AWDATA_RX(phy_err_stats[ATH9K_PHYERR_CCK_TIMING]); 1522 1523 WARN_ON(i != ATH9K_SSTATS_LEN); 1524 } 1525 1526 void ath9k_deinit_debug(struct ath_softc *sc) 1527 { 1528 ath9k_spectral_deinit_debug(sc); 1529 } 1530 1531 int ath9k_init_debug(struct ath_hw *ah) 1532 { 1533 struct ath_common *common = ath9k_hw_common(ah); 1534 struct ath_softc *sc = (struct ath_softc *) common->priv; 1535 1536 sc->debug.debugfs_phy = debugfs_create_dir("ath9k", 1537 sc->hw->wiphy->debugfsdir); 1538 if (!sc->debug.debugfs_phy) 1539 return -ENOMEM; 1540 1541 #ifdef CONFIG_ATH_DEBUG 1542 debugfs_create_file("debug", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, 1543 sc, &fops_debug); 1544 #endif 1545 1546 ath9k_dfs_init_debug(sc); 1547 ath9k_tx99_init_debug(sc); 1548 ath9k_spectral_init_debug(sc); 1549 1550 debugfs_create_file("dma", S_IRUSR, sc->debug.debugfs_phy, sc, 1551 &fops_dma); 1552 debugfs_create_file("interrupt", S_IRUSR, sc->debug.debugfs_phy, sc, 1553 &fops_interrupt); 1554 debugfs_create_file("xmit", S_IRUSR, sc->debug.debugfs_phy, sc, 1555 &fops_xmit); 1556 debugfs_create_file("queues", S_IRUSR, sc->debug.debugfs_phy, sc, 1557 &fops_queues); 1558 debugfs_create_u32("qlen_bk", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, 1559 &sc->tx.txq_max_pending[IEEE80211_AC_BK]); 1560 debugfs_create_u32("qlen_be", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, 1561 &sc->tx.txq_max_pending[IEEE80211_AC_BE]); 1562 debugfs_create_u32("qlen_vi", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, 1563 &sc->tx.txq_max_pending[IEEE80211_AC_VI]); 1564 debugfs_create_u32("qlen_vo", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, 1565 &sc->tx.txq_max_pending[IEEE80211_AC_VO]); 1566 debugfs_create_file("misc", S_IRUSR, sc->debug.debugfs_phy, sc, 1567 &fops_misc); 1568 debugfs_create_file("reset", S_IRUSR, sc->debug.debugfs_phy, sc, 1569 &fops_reset); 1570 debugfs_create_file("recv", S_IRUSR, sc->debug.debugfs_phy, sc, 1571 &fops_recv); 1572 debugfs_create_u8("rx_chainmask", S_IRUSR, sc->debug.debugfs_phy, 1573 &ah->rxchainmask); 1574 debugfs_create_u8("tx_chainmask", S_IRUSR, sc->debug.debugfs_phy, 1575 &ah->txchainmask); 1576 debugfs_create_file("ani", S_IRUSR | S_IWUSR, 1577 sc->debug.debugfs_phy, sc, &fops_ani); 1578 debugfs_create_bool("paprd", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, 1579 &sc->sc_ah->config.enable_paprd); 1580 debugfs_create_file("regidx", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, 1581 sc, &fops_regidx); 1582 debugfs_create_file("regval", S_IRUSR | S_IWUSR, sc->debug.debugfs_phy, 1583 sc, &fops_regval); 1584 debugfs_create_bool("ignore_extcca", S_IRUSR | S_IWUSR, 1585 sc->debug.debugfs_phy, 1586 &ah->config.cwm_ignore_extcca); 1587 debugfs_create_file("regdump", S_IRUSR, sc->debug.debugfs_phy, sc, 1588 &fops_regdump); 1589 debugfs_create_file("dump_nfcal", S_IRUSR, sc->debug.debugfs_phy, sc, 1590 &fops_dump_nfcal); 1591 debugfs_create_file("base_eeprom", S_IRUSR, sc->debug.debugfs_phy, sc, 1592 &fops_base_eeprom); 1593 debugfs_create_file("modal_eeprom", S_IRUSR, sc->debug.debugfs_phy, sc, 1594 &fops_modal_eeprom); 1595 debugfs_create_u32("gpio_mask", S_IRUSR | S_IWUSR, 1596 sc->debug.debugfs_phy, &sc->sc_ah->gpio_mask); 1597 debugfs_create_u32("gpio_val", S_IRUSR | S_IWUSR, 1598 sc->debug.debugfs_phy, &sc->sc_ah->gpio_val); 1599 debugfs_create_file("antenna_diversity", S_IRUSR, 1600 sc->debug.debugfs_phy, sc, &fops_antenna_diversity); 1601 #ifdef CONFIG_ATH9K_BTCOEX_SUPPORT 1602 debugfs_create_file("bt_ant_diversity", S_IRUSR | S_IWUSR, 1603 sc->debug.debugfs_phy, sc, &fops_bt_ant_diversity); 1604 debugfs_create_file("btcoex", S_IRUSR, sc->debug.debugfs_phy, sc, 1605 &fops_btcoex); 1606 #endif 1607 1608 return 0; 1609 } 1610