1 /* 2 * Atheros CARL9170 driver 3 * 4 * debug(fs) probing 5 * 6 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net> 7 * Copyright 2009, 2010, Christian Lamparter <chunkeey@googlemail.com> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; see the file COPYING. If not, see 21 * http://www.gnu.org/licenses/. 22 * 23 * This file incorporates work covered by the following copyright and 24 * permission notice: 25 * Copyright (c) 2008-2009 Atheros Communications, Inc. 26 * 27 * Permission to use, copy, modify, and/or distribute this software for any 28 * purpose with or without fee is hereby granted, provided that the above 29 * copyright notice and this permission notice appear in all copies. 30 * 31 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 32 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 33 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 34 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 35 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 36 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 37 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 38 */ 39 40 #include <linux/slab.h> 41 #include <linux/module.h> 42 #include <linux/seq_file.h> 43 #include <linux/vmalloc.h> 44 #include "carl9170.h" 45 #include "cmd.h" 46 47 #define ADD(buf, off, max, fmt, args...) \ 48 off += scnprintf(&buf[off], max - off, fmt, ##args) 49 50 51 struct carl9170_debugfs_fops { 52 unsigned int read_bufsize; 53 umode_t attr; 54 char *(*read)(struct ar9170 *ar, char *buf, size_t bufsize, 55 ssize_t *len); 56 ssize_t (*write)(struct ar9170 *aru, const char *buf, size_t size); 57 58 enum carl9170_device_state req_dev_state; 59 }; 60 61 static ssize_t carl9170_debugfs_read(struct file *file, char __user *userbuf, 62 size_t count, loff_t *ppos) 63 { 64 const struct carl9170_debugfs_fops *dfops; 65 struct ar9170 *ar; 66 char *buf = NULL, *res_buf = NULL; 67 ssize_t ret = 0; 68 int err = 0; 69 70 if (!count) 71 return 0; 72 73 ar = file->private_data; 74 75 if (!ar) 76 return -ENODEV; 77 dfops = debugfs_get_aux(file); 78 79 if (!dfops->read) 80 return -ENOSYS; 81 82 if (dfops->read_bufsize) { 83 buf = vmalloc(dfops->read_bufsize); 84 if (!buf) 85 return -ENOMEM; 86 } 87 88 mutex_lock(&ar->mutex); 89 if (!CHK_DEV_STATE(ar, dfops->req_dev_state)) { 90 err = -ENODEV; 91 res_buf = buf; 92 goto out_free; 93 } 94 95 res_buf = dfops->read(ar, buf, dfops->read_bufsize, &ret); 96 97 if (ret > 0) 98 err = simple_read_from_buffer(userbuf, count, ppos, 99 res_buf, ret); 100 else 101 err = ret; 102 103 WARN_ON_ONCE(dfops->read_bufsize && (res_buf != buf)); 104 105 out_free: 106 vfree(res_buf); 107 mutex_unlock(&ar->mutex); 108 return err; 109 } 110 111 static ssize_t carl9170_debugfs_write(struct file *file, 112 const char __user *userbuf, size_t count, loff_t *ppos) 113 { 114 const struct carl9170_debugfs_fops *dfops; 115 struct ar9170 *ar; 116 char *buf = NULL; 117 int err = 0; 118 119 if (!count) 120 return 0; 121 122 if (count > PAGE_SIZE) 123 return -E2BIG; 124 125 ar = file->private_data; 126 127 if (!ar) 128 return -ENODEV; 129 dfops = debugfs_get_aux(file); 130 131 if (!dfops->write) 132 return -ENOSYS; 133 134 buf = vmalloc(count); 135 if (!buf) 136 return -ENOMEM; 137 138 if (copy_from_user(buf, userbuf, count)) { 139 err = -EFAULT; 140 goto out_free; 141 } 142 143 if (mutex_trylock(&ar->mutex) == 0) { 144 err = -EAGAIN; 145 goto out_free; 146 } 147 148 if (!CHK_DEV_STATE(ar, dfops->req_dev_state)) { 149 err = -ENODEV; 150 goto out_unlock; 151 } 152 153 err = dfops->write(ar, buf, count); 154 if (err) 155 goto out_unlock; 156 157 out_unlock: 158 mutex_unlock(&ar->mutex); 159 160 out_free: 161 vfree(buf); 162 return err; 163 } 164 165 static struct debugfs_short_fops debugfs_fops = { 166 .read = carl9170_debugfs_read, 167 .write = carl9170_debugfs_write, 168 }; 169 170 #define __DEBUGFS_DECLARE_FILE(name, _read, _write, _read_bufsize, \ 171 _attr, _dstate) \ 172 static const struct carl9170_debugfs_fops carl_debugfs_##name ##_ops = {\ 173 .read_bufsize = _read_bufsize, \ 174 .read = _read, \ 175 .write = _write, \ 176 .attr = _attr, \ 177 .req_dev_state = _dstate, \ 178 } 179 180 #define DEBUGFS_DECLARE_FILE(name, _read, _write, _read_bufsize, _attr) \ 181 __DEBUGFS_DECLARE_FILE(name, _read, _write, _read_bufsize, \ 182 _attr, CARL9170_STARTED) \ 183 184 #define DEBUGFS_DECLARE_RO_FILE(name, _read_bufsize) \ 185 DEBUGFS_DECLARE_FILE(name, carl9170_debugfs_##name ##_read, \ 186 NULL, _read_bufsize, 0400) 187 188 #define DEBUGFS_DECLARE_WO_FILE(name) \ 189 DEBUGFS_DECLARE_FILE(name, NULL, carl9170_debugfs_##name ##_write,\ 190 0, 0200) 191 192 #define DEBUGFS_DECLARE_RW_FILE(name, _read_bufsize) \ 193 DEBUGFS_DECLARE_FILE(name, carl9170_debugfs_##name ##_read, \ 194 carl9170_debugfs_##name ##_write, \ 195 _read_bufsize, 0600) 196 197 #define __DEBUGFS_DECLARE_RW_FILE(name, _read_bufsize, _dstate) \ 198 __DEBUGFS_DECLARE_FILE(name, carl9170_debugfs_##name ##_read, \ 199 carl9170_debugfs_##name ##_write, \ 200 _read_bufsize, 0600, _dstate) 201 202 #define DEBUGFS_READONLY_FILE(name, _read_bufsize, fmt, value...) \ 203 static char *carl9170_debugfs_ ##name ## _read(struct ar9170 *ar, \ 204 char *buf, size_t buf_size,\ 205 ssize_t *len) \ 206 { \ 207 ADD(buf, *len, buf_size, fmt "\n", ##value); \ 208 return buf; \ 209 } \ 210 DEBUGFS_DECLARE_RO_FILE(name, _read_bufsize) 211 212 static char *carl9170_debugfs_mem_usage_read(struct ar9170 *ar, char *buf, 213 size_t bufsize, ssize_t *len) 214 { 215 spin_lock_bh(&ar->mem_lock); 216 217 ADD(buf, *len, bufsize, "jar: [%*pb]\n", 218 ar->fw.mem_blocks, ar->mem_bitmap); 219 220 ADD(buf, *len, bufsize, "cookies: used:%3d / total:%3d, allocs:%d\n", 221 bitmap_weight(ar->mem_bitmap, ar->fw.mem_blocks), 222 ar->fw.mem_blocks, atomic_read(&ar->mem_allocs)); 223 224 ADD(buf, *len, bufsize, "memory: free:%3d (%3d KiB) / total:%3d KiB)\n", 225 atomic_read(&ar->mem_free_blocks), 226 (atomic_read(&ar->mem_free_blocks) * ar->fw.mem_block_size) / 1024, 227 (ar->fw.mem_blocks * ar->fw.mem_block_size) / 1024); 228 229 spin_unlock_bh(&ar->mem_lock); 230 231 return buf; 232 } 233 DEBUGFS_DECLARE_RO_FILE(mem_usage, 512); 234 235 static char *carl9170_debugfs_qos_stat_read(struct ar9170 *ar, char *buf, 236 size_t bufsize, ssize_t *len) 237 { 238 ADD(buf, *len, bufsize, "%s QoS AC\n", modparam_noht ? "Hardware" : 239 "Software"); 240 241 ADD(buf, *len, bufsize, "[ VO VI " 242 " BE BK ]\n"); 243 244 spin_lock_bh(&ar->tx_stats_lock); 245 ADD(buf, *len, bufsize, "[length/limit length/limit " 246 "length/limit length/limit ]\n" 247 "[ %3d/%3d %3d/%3d " 248 " %3d/%3d %3d/%3d ]\n\n", 249 ar->tx_stats[0].len, ar->tx_stats[0].limit, 250 ar->tx_stats[1].len, ar->tx_stats[1].limit, 251 ar->tx_stats[2].len, ar->tx_stats[2].limit, 252 ar->tx_stats[3].len, ar->tx_stats[3].limit); 253 254 ADD(buf, *len, bufsize, "[ total total " 255 " total total ]\n" 256 "[%10d %10d %10d %10d ]\n\n", 257 ar->tx_stats[0].count, ar->tx_stats[1].count, 258 ar->tx_stats[2].count, ar->tx_stats[3].count); 259 260 spin_unlock_bh(&ar->tx_stats_lock); 261 262 ADD(buf, *len, bufsize, "[ pend/waittx pend/waittx " 263 " pend/waittx pend/waittx]\n" 264 "[ %3d/%3d %3d/%3d " 265 " %3d/%3d %3d/%3d ]\n\n", 266 skb_queue_len(&ar->tx_pending[0]), 267 skb_queue_len(&ar->tx_status[0]), 268 skb_queue_len(&ar->tx_pending[1]), 269 skb_queue_len(&ar->tx_status[1]), 270 skb_queue_len(&ar->tx_pending[2]), 271 skb_queue_len(&ar->tx_status[2]), 272 skb_queue_len(&ar->tx_pending[3]), 273 skb_queue_len(&ar->tx_status[3])); 274 275 return buf; 276 } 277 DEBUGFS_DECLARE_RO_FILE(qos_stat, 512); 278 279 static void carl9170_debugfs_format_frame(struct ar9170 *ar, 280 struct sk_buff *skb, const char *prefix, char *buf, 281 ssize_t *off, ssize_t bufsize) 282 { 283 struct _carl9170_tx_superframe *txc = (void *) skb->data; 284 struct ieee80211_tx_info *txinfo = IEEE80211_SKB_CB(skb); 285 struct carl9170_tx_info *arinfo = (void *) txinfo->rate_driver_data; 286 struct ieee80211_hdr *hdr = (void *) txc->frame_data; 287 288 ADD(buf, *off, bufsize, "%s %p, c:%2x, DA:%pM, sq:%4d, mc:%.4x, " 289 "pc:%.8x, to:%d ms\n", prefix, skb, txc->s.cookie, 290 ieee80211_get_DA(hdr), get_seq_h(hdr), 291 le16_to_cpu(txc->f.mac_control), le32_to_cpu(txc->f.phy_control), 292 jiffies_to_msecs(jiffies - arinfo->timeout)); 293 } 294 295 296 static char *carl9170_debugfs_ampdu_state_read(struct ar9170 *ar, char *buf, 297 size_t bufsize, ssize_t *len) 298 { 299 struct carl9170_sta_tid *iter; 300 struct sk_buff *skb; 301 int cnt = 0, fc; 302 int offset; 303 304 rcu_read_lock(); 305 list_for_each_entry_rcu(iter, &ar->tx_ampdu_list, list) { 306 307 spin_lock_bh(&iter->lock); 308 ADD(buf, *len, bufsize, "Entry: #%2d TID:%1d, BSN:%4d, " 309 "SNX:%4d, HSN:%4d, BAW:%2d, state:%1d, toggles:%d\n", 310 cnt, iter->tid, iter->bsn, iter->snx, iter->hsn, 311 iter->max, iter->state, iter->counter); 312 313 ADD(buf, *len, bufsize, "\tWindow: [%*pb,W]\n", 314 CARL9170_BAW_BITS, iter->bitmap); 315 316 #define BM_STR_OFF(offset) \ 317 ((CARL9170_BAW_BITS - (offset) - 1) / 4 + \ 318 (CARL9170_BAW_BITS - (offset) - 1) / 32 + 1) 319 320 offset = BM_STR_OFF(0); 321 ADD(buf, *len, bufsize, "\tBase Seq: %*s\n", offset, "T"); 322 323 offset = BM_STR_OFF(SEQ_DIFF(iter->snx, iter->bsn)); 324 ADD(buf, *len, bufsize, "\tNext Seq: %*s\n", offset, "W"); 325 326 offset = BM_STR_OFF(((int)iter->hsn - (int)iter->bsn) % 327 CARL9170_BAW_BITS); 328 ADD(buf, *len, bufsize, "\tLast Seq: %*s\n", offset, "N"); 329 330 ADD(buf, *len, bufsize, "\tPre-Aggregation reorder buffer: " 331 " currently queued:%d\n", skb_queue_len(&iter->queue)); 332 333 fc = 0; 334 skb_queue_walk(&iter->queue, skb) { 335 char prefix[32]; 336 337 snprintf(prefix, sizeof(prefix), "\t\t%3d :", fc); 338 carl9170_debugfs_format_frame(ar, skb, prefix, buf, 339 len, bufsize); 340 341 fc++; 342 } 343 spin_unlock_bh(&iter->lock); 344 cnt++; 345 } 346 rcu_read_unlock(); 347 348 return buf; 349 } 350 DEBUGFS_DECLARE_RO_FILE(ampdu_state, 8000); 351 352 static void carl9170_debugfs_queue_dump(struct ar9170 *ar, char *buf, 353 ssize_t *len, size_t bufsize, struct sk_buff_head *queue) 354 { 355 struct sk_buff *skb; 356 char prefix[16]; 357 int fc = 0; 358 359 spin_lock_bh(&queue->lock); 360 skb_queue_walk(queue, skb) { 361 snprintf(prefix, sizeof(prefix), "%3d :", fc); 362 carl9170_debugfs_format_frame(ar, skb, prefix, buf, 363 len, bufsize); 364 fc++; 365 } 366 spin_unlock_bh(&queue->lock); 367 } 368 369 #define DEBUGFS_QUEUE_DUMP(q, qi) \ 370 static char *carl9170_debugfs_##q ##_##qi ##_read(struct ar9170 *ar, \ 371 char *buf, size_t bufsize, ssize_t *len) \ 372 { \ 373 carl9170_debugfs_queue_dump(ar, buf, len, bufsize, &ar->q[qi]); \ 374 return buf; \ 375 } \ 376 DEBUGFS_DECLARE_RO_FILE(q##_##qi, 8000); 377 378 static char *carl9170_debugfs_sta_psm_read(struct ar9170 *ar, char *buf, 379 size_t bufsize, ssize_t *len) 380 { 381 ADD(buf, *len, bufsize, "psm state: %s\n", (ar->ps.off_override ? 382 "FORCE CAM" : (ar->ps.state ? "PSM" : "CAM"))); 383 384 ADD(buf, *len, bufsize, "sleep duration: %d ms.\n", ar->ps.sleep_ms); 385 ADD(buf, *len, bufsize, "last power-state transition: %d ms ago.\n", 386 jiffies_to_msecs(jiffies - ar->ps.last_action)); 387 ADD(buf, *len, bufsize, "last CAM->PSM transition: %d ms ago.\n", 388 jiffies_to_msecs(jiffies - ar->ps.last_slept)); 389 390 return buf; 391 } 392 DEBUGFS_DECLARE_RO_FILE(sta_psm, 160); 393 394 static char *carl9170_debugfs_tx_stuck_read(struct ar9170 *ar, char *buf, 395 size_t bufsize, ssize_t *len) 396 { 397 int i; 398 399 for (i = 0; i < ar->hw->queues; i++) { 400 ADD(buf, *len, bufsize, "TX queue [%d]: %10d max:%10d ms.\n", 401 i, ieee80211_queue_stopped(ar->hw, i) ? 402 jiffies_to_msecs(jiffies - ar->queue_stop_timeout[i]) : 0, 403 jiffies_to_msecs(ar->max_queue_stop_timeout[i])); 404 405 ar->max_queue_stop_timeout[i] = 0; 406 } 407 408 return buf; 409 } 410 DEBUGFS_DECLARE_RO_FILE(tx_stuck, 180); 411 412 static char *carl9170_debugfs_phy_noise_read(struct ar9170 *ar, char *buf, 413 size_t bufsize, ssize_t *len) 414 { 415 int err; 416 417 err = carl9170_get_noisefloor(ar); 418 if (err) { 419 *len = err; 420 return buf; 421 } 422 423 ADD(buf, *len, bufsize, "Chain 0: %10d dBm, ext. chan.:%10d dBm\n", 424 ar->noise[0], ar->noise[2]); 425 ADD(buf, *len, bufsize, "Chain 2: %10d dBm, ext. chan.:%10d dBm\n", 426 ar->noise[1], ar->noise[3]); 427 428 return buf; 429 } 430 DEBUGFS_DECLARE_RO_FILE(phy_noise, 180); 431 432 static char *carl9170_debugfs_vif_dump_read(struct ar9170 *ar, char *buf, 433 size_t bufsize, ssize_t *len) 434 { 435 struct carl9170_vif_info *iter; 436 int i = 0; 437 438 ADD(buf, *len, bufsize, "registered VIFs:%d \\ %d\n", 439 ar->vifs, ar->fw.vif_num); 440 441 ADD(buf, *len, bufsize, "VIF bitmap: [%*pb]\n", 442 ar->fw.vif_num, &ar->vif_bitmap); 443 444 rcu_read_lock(); 445 list_for_each_entry_rcu(iter, &ar->vif_list, list) { 446 struct ieee80211_vif *vif = carl9170_get_vif(iter); 447 ADD(buf, *len, bufsize, "\t%d = [%s VIF, id:%d, type:%x " 448 " mac:%pM %s]\n", i, (carl9170_get_main_vif(ar) == vif ? 449 "Master" : " Slave"), iter->id, vif->type, vif->addr, 450 iter->enable_beacon ? "beaconing " : ""); 451 i++; 452 } 453 rcu_read_unlock(); 454 455 return buf; 456 } 457 DEBUGFS_DECLARE_RO_FILE(vif_dump, 8000); 458 459 #define UPDATE_COUNTER(ar, name) ({ \ 460 u32 __tmp[ARRAY_SIZE(name##_regs)]; \ 461 unsigned int __i, __err = -ENODEV; \ 462 \ 463 for (__i = 0; __i < ARRAY_SIZE(name##_regs); __i++) { \ 464 __tmp[__i] = name##_regs[__i].reg; \ 465 ar->debug.stats.name##_counter[__i] = 0; \ 466 } \ 467 \ 468 if (IS_STARTED(ar)) \ 469 __err = carl9170_read_mreg(ar, ARRAY_SIZE(name##_regs), \ 470 __tmp, ar->debug.stats.name##_counter); \ 471 (__err); }) 472 473 #define TALLY_SUM_UP(ar, name) do { \ 474 unsigned int __i; \ 475 \ 476 for (__i = 0; __i < ARRAY_SIZE(name##_regs); __i++) { \ 477 ar->debug.stats.name##_sum[__i] += \ 478 ar->debug.stats.name##_counter[__i]; \ 479 } \ 480 } while (0) 481 482 #define DEBUGFS_HW_TALLY_FILE(name, f) \ 483 static char *carl9170_debugfs_##name ## _read(struct ar9170 *ar, \ 484 char *dum, size_t bufsize, ssize_t *ret) \ 485 { \ 486 char *buf; \ 487 int i, max_len, err; \ 488 \ 489 max_len = ARRAY_SIZE(name##_regs) * 80; \ 490 buf = vmalloc(max_len); \ 491 if (!buf) \ 492 return NULL; \ 493 \ 494 err = UPDATE_COUNTER(ar, name); \ 495 if (err) { \ 496 *ret = err; \ 497 return buf; \ 498 } \ 499 \ 500 TALLY_SUM_UP(ar, name); \ 501 \ 502 for (i = 0; i < ARRAY_SIZE(name##_regs); i++) { \ 503 ADD(buf, *ret, max_len, "%22s = %" f "[+%" f "]\n", \ 504 name##_regs[i].nreg, ar->debug.stats.name ##_sum[i],\ 505 ar->debug.stats.name ##_counter[i]); \ 506 } \ 507 \ 508 return buf; \ 509 } \ 510 DEBUGFS_DECLARE_RO_FILE(name, 0); 511 512 #define DEBUGFS_HW_REG_FILE(name, f) \ 513 static char *carl9170_debugfs_##name ## _read(struct ar9170 *ar, \ 514 char *dum, size_t bufsize, ssize_t *ret) \ 515 { \ 516 char *buf; \ 517 int i, max_len, err; \ 518 \ 519 max_len = ARRAY_SIZE(name##_regs) * 80; \ 520 buf = vmalloc(max_len); \ 521 if (!buf) \ 522 return NULL; \ 523 \ 524 err = UPDATE_COUNTER(ar, name); \ 525 if (err) { \ 526 *ret = err; \ 527 return buf; \ 528 } \ 529 \ 530 for (i = 0; i < ARRAY_SIZE(name##_regs); i++) { \ 531 ADD(buf, *ret, max_len, "%22s = %" f "\n", \ 532 name##_regs[i].nreg, \ 533 ar->debug.stats.name##_counter[i]); \ 534 } \ 535 \ 536 return buf; \ 537 } \ 538 DEBUGFS_DECLARE_RO_FILE(name, 0); 539 540 static ssize_t carl9170_debugfs_hw_ioread32_write(struct ar9170 *ar, 541 const char *buf, size_t count) 542 { 543 int err = 0, i, n = 0, max_len = 32, res; 544 unsigned int reg, tmp; 545 546 if (!count) 547 return 0; 548 549 if (count > max_len) 550 return -E2BIG; 551 552 res = sscanf(buf, "0x%X %d", ®, &n); 553 if (res < 1) { 554 err = -EINVAL; 555 goto out; 556 } 557 558 if (res == 1) 559 n = 1; 560 561 if (n > 15) { 562 err = -EMSGSIZE; 563 goto out; 564 } 565 566 if ((reg >= 0x280000) || ((reg + (n << 2)) >= 0x280000)) { 567 err = -EADDRNOTAVAIL; 568 goto out; 569 } 570 571 if (reg & 3) { 572 err = -EINVAL; 573 goto out; 574 } 575 576 for (i = 0; i < n; i++) { 577 err = carl9170_read_reg(ar, reg + (i << 2), &tmp); 578 if (err) 579 goto out; 580 581 ar->debug.ring[ar->debug.ring_tail].reg = reg + (i << 2); 582 ar->debug.ring[ar->debug.ring_tail].value = tmp; 583 ar->debug.ring_tail++; 584 ar->debug.ring_tail %= CARL9170_DEBUG_RING_SIZE; 585 } 586 587 out: 588 return err ? err : count; 589 } 590 591 static char *carl9170_debugfs_hw_ioread32_read(struct ar9170 *ar, char *buf, 592 size_t bufsize, ssize_t *ret) 593 { 594 int i = 0; 595 596 while (ar->debug.ring_head != ar->debug.ring_tail) { 597 ADD(buf, *ret, bufsize, "%.8x = %.8x\n", 598 ar->debug.ring[ar->debug.ring_head].reg, 599 ar->debug.ring[ar->debug.ring_head].value); 600 601 ar->debug.ring_head++; 602 ar->debug.ring_head %= CARL9170_DEBUG_RING_SIZE; 603 604 if (i++ == 64) 605 break; 606 } 607 ar->debug.ring_head = ar->debug.ring_tail; 608 return buf; 609 } 610 DEBUGFS_DECLARE_RW_FILE(hw_ioread32, CARL9170_DEBUG_RING_SIZE * 40); 611 612 static ssize_t carl9170_debugfs_bug_write(struct ar9170 *ar, const char *buf, 613 size_t count) 614 { 615 int err; 616 617 if (count < 1) 618 return -EINVAL; 619 620 switch (buf[0]) { 621 case 'F': 622 ar->needs_full_reset = true; 623 break; 624 625 case 'R': 626 if (!IS_STARTED(ar)) { 627 err = -EAGAIN; 628 goto out; 629 } 630 631 ar->needs_full_reset = false; 632 break; 633 634 case 'M': 635 err = carl9170_mac_reset(ar); 636 if (err < 0) 637 count = err; 638 639 goto out; 640 641 case 'P': 642 err = carl9170_set_channel(ar, ar->hw->conf.chandef.chan, 643 cfg80211_get_chandef_type(&ar->hw->conf.chandef)); 644 if (err < 0) 645 count = err; 646 647 goto out; 648 649 default: 650 return -EINVAL; 651 } 652 653 carl9170_restart(ar, CARL9170_RR_USER_REQUEST); 654 655 out: 656 return count; 657 } 658 659 static char *carl9170_debugfs_bug_read(struct ar9170 *ar, char *buf, 660 size_t bufsize, ssize_t *ret) 661 { 662 ADD(buf, *ret, bufsize, "[P]hy reinit, [R]estart, [F]ull usb reset, " 663 "[M]ac reset\n"); 664 ADD(buf, *ret, bufsize, "firmware restarts:%d, last reason:%d\n", 665 ar->restart_counter, ar->last_reason); 666 ADD(buf, *ret, bufsize, "phy reinit errors:%d (%d)\n", 667 ar->total_chan_fail, ar->chan_fail); 668 ADD(buf, *ret, bufsize, "reported firmware errors:%d\n", 669 ar->fw.err_counter); 670 ADD(buf, *ret, bufsize, "reported firmware BUGs:%d\n", 671 ar->fw.bug_counter); 672 ADD(buf, *ret, bufsize, "pending restart requests:%d\n", 673 atomic_read(&ar->pending_restarts)); 674 return buf; 675 } 676 __DEBUGFS_DECLARE_RW_FILE(bug, 400, CARL9170_STOPPED); 677 678 static const char *const erp_modes[] = { 679 [CARL9170_ERP_INVALID] = "INVALID", 680 [CARL9170_ERP_AUTO] = "Automatic", 681 [CARL9170_ERP_MAC80211] = "Set by MAC80211", 682 [CARL9170_ERP_OFF] = "Force Off", 683 [CARL9170_ERP_RTS] = "Force RTS", 684 [CARL9170_ERP_CTS] = "Force CTS" 685 }; 686 687 static char *carl9170_debugfs_erp_read(struct ar9170 *ar, char *buf, 688 size_t bufsize, ssize_t *ret) 689 { 690 ADD(buf, *ret, bufsize, "ERP Setting: (%d) -> %s\n", ar->erp_mode, 691 erp_modes[ar->erp_mode]); 692 return buf; 693 } 694 695 static ssize_t carl9170_debugfs_erp_write(struct ar9170 *ar, const char *buf, 696 size_t count) 697 { 698 int res, val; 699 700 if (count < 1) 701 return -EINVAL; 702 703 res = sscanf(buf, "%d", &val); 704 if (res != 1) 705 return -EINVAL; 706 707 if (!((val > CARL9170_ERP_INVALID) && 708 (val < __CARL9170_ERP_NUM))) 709 return -EINVAL; 710 711 ar->erp_mode = val; 712 return count; 713 } 714 715 DEBUGFS_DECLARE_RW_FILE(erp, 80); 716 717 static ssize_t carl9170_debugfs_hw_iowrite32_write(struct ar9170 *ar, 718 const char *buf, size_t count) 719 { 720 int err = 0, max_len = 22, res; 721 u32 reg, val; 722 723 if (!count) 724 return 0; 725 726 if (count > max_len) 727 return -E2BIG; 728 729 res = sscanf(buf, "0x%X 0x%X", ®, &val); 730 if (res != 2) { 731 err = -EINVAL; 732 goto out; 733 } 734 735 if (reg <= 0x100000 || reg >= 0x280000) { 736 err = -EADDRNOTAVAIL; 737 goto out; 738 } 739 740 if (reg & 3) { 741 err = -EINVAL; 742 goto out; 743 } 744 745 err = carl9170_write_reg(ar, reg, val); 746 if (err) 747 goto out; 748 749 out: 750 return err ? err : count; 751 } 752 DEBUGFS_DECLARE_WO_FILE(hw_iowrite32); 753 754 DEBUGFS_HW_TALLY_FILE(hw_tx_tally, "u"); 755 DEBUGFS_HW_TALLY_FILE(hw_rx_tally, "u"); 756 DEBUGFS_HW_TALLY_FILE(hw_phy_errors, "u"); 757 DEBUGFS_HW_REG_FILE(hw_wlan_queue, ".8x"); 758 DEBUGFS_HW_REG_FILE(hw_pta_queue, ".8x"); 759 DEBUGFS_HW_REG_FILE(hw_ampdu_info, ".8x"); 760 DEBUGFS_QUEUE_DUMP(tx_status, 0); 761 DEBUGFS_QUEUE_DUMP(tx_status, 1); 762 DEBUGFS_QUEUE_DUMP(tx_status, 2); 763 DEBUGFS_QUEUE_DUMP(tx_status, 3); 764 DEBUGFS_QUEUE_DUMP(tx_pending, 0); 765 DEBUGFS_QUEUE_DUMP(tx_pending, 1); 766 DEBUGFS_QUEUE_DUMP(tx_pending, 2); 767 DEBUGFS_QUEUE_DUMP(tx_pending, 3); 768 DEBUGFS_READONLY_FILE(usb_tx_anch_urbs, 20, "%d", 769 atomic_read(&ar->tx_anch_urbs)); 770 DEBUGFS_READONLY_FILE(usb_rx_anch_urbs, 20, "%d", 771 atomic_read(&ar->rx_anch_urbs)); 772 DEBUGFS_READONLY_FILE(usb_rx_work_urbs, 20, "%d", 773 atomic_read(&ar->rx_work_urbs)); 774 DEBUGFS_READONLY_FILE(usb_rx_pool_urbs, 20, "%d", 775 atomic_read(&ar->rx_pool_urbs)); 776 777 DEBUGFS_READONLY_FILE(tx_total_queued, 20, "%d", 778 atomic_read(&ar->tx_total_queued)); 779 DEBUGFS_READONLY_FILE(tx_ampdu_scheduler, 20, "%d", 780 atomic_read(&ar->tx_ampdu_scheduler)); 781 782 DEBUGFS_READONLY_FILE(tx_total_pending, 20, "%d", 783 atomic_read(&ar->tx_total_pending)); 784 785 DEBUGFS_READONLY_FILE(tx_ampdu_list_len, 20, "%d", 786 ar->tx_ampdu_list_len); 787 788 DEBUGFS_READONLY_FILE(tx_ampdu_upload, 20, "%d", 789 atomic_read(&ar->tx_ampdu_upload)); 790 791 DEBUGFS_READONLY_FILE(tx_janitor_last_run, 64, "last run:%d ms ago", 792 jiffies_to_msecs(jiffies - ar->tx_janitor_last_run)); 793 794 DEBUGFS_READONLY_FILE(tx_dropped, 20, "%d", ar->tx_dropped); 795 796 DEBUGFS_READONLY_FILE(rx_dropped, 20, "%d", ar->rx_dropped); 797 798 DEBUGFS_READONLY_FILE(sniffer_enabled, 20, "%d", ar->sniffer_enabled); 799 DEBUGFS_READONLY_FILE(rx_software_decryption, 20, "%d", 800 ar->rx_software_decryption); 801 DEBUGFS_READONLY_FILE(ampdu_factor, 20, "%d", 802 ar->current_factor); 803 DEBUGFS_READONLY_FILE(ampdu_density, 20, "%d", 804 ar->current_density); 805 806 DEBUGFS_READONLY_FILE(beacon_int, 20, "%d TU", ar->global_beacon_int); 807 DEBUGFS_READONLY_FILE(pretbtt, 20, "%d TU", ar->global_pretbtt); 808 809 void carl9170_debugfs_register(struct ar9170 *ar) 810 { 811 ar->debug_dir = debugfs_create_dir(KBUILD_MODNAME, 812 ar->hw->wiphy->debugfsdir); 813 814 #define DEBUGFS_ADD(name) \ 815 debugfs_create_file_aux(#name, carl_debugfs_##name ##_ops.attr, \ 816 ar->debug_dir, ar, &carl_debugfs_##name ## _ops, \ 817 &debugfs_fops) 818 819 DEBUGFS_ADD(usb_tx_anch_urbs); 820 DEBUGFS_ADD(usb_rx_pool_urbs); 821 DEBUGFS_ADD(usb_rx_anch_urbs); 822 DEBUGFS_ADD(usb_rx_work_urbs); 823 824 DEBUGFS_ADD(tx_total_queued); 825 DEBUGFS_ADD(tx_total_pending); 826 DEBUGFS_ADD(tx_dropped); 827 DEBUGFS_ADD(tx_stuck); 828 DEBUGFS_ADD(tx_ampdu_upload); 829 DEBUGFS_ADD(tx_ampdu_scheduler); 830 DEBUGFS_ADD(tx_ampdu_list_len); 831 832 DEBUGFS_ADD(rx_dropped); 833 DEBUGFS_ADD(sniffer_enabled); 834 DEBUGFS_ADD(rx_software_decryption); 835 836 DEBUGFS_ADD(mem_usage); 837 DEBUGFS_ADD(qos_stat); 838 DEBUGFS_ADD(sta_psm); 839 DEBUGFS_ADD(ampdu_state); 840 841 DEBUGFS_ADD(hw_tx_tally); 842 DEBUGFS_ADD(hw_rx_tally); 843 DEBUGFS_ADD(hw_phy_errors); 844 DEBUGFS_ADD(phy_noise); 845 846 DEBUGFS_ADD(hw_wlan_queue); 847 DEBUGFS_ADD(hw_pta_queue); 848 DEBUGFS_ADD(hw_ampdu_info); 849 850 DEBUGFS_ADD(ampdu_density); 851 DEBUGFS_ADD(ampdu_factor); 852 853 DEBUGFS_ADD(tx_janitor_last_run); 854 855 DEBUGFS_ADD(tx_status_0); 856 DEBUGFS_ADD(tx_status_1); 857 DEBUGFS_ADD(tx_status_2); 858 DEBUGFS_ADD(tx_status_3); 859 860 DEBUGFS_ADD(tx_pending_0); 861 DEBUGFS_ADD(tx_pending_1); 862 DEBUGFS_ADD(tx_pending_2); 863 DEBUGFS_ADD(tx_pending_3); 864 865 DEBUGFS_ADD(hw_ioread32); 866 DEBUGFS_ADD(hw_iowrite32); 867 DEBUGFS_ADD(bug); 868 869 DEBUGFS_ADD(erp); 870 871 DEBUGFS_ADD(vif_dump); 872 873 DEBUGFS_ADD(beacon_int); 874 DEBUGFS_ADD(pretbtt); 875 876 #undef DEBUGFS_ADD 877 } 878 879 void carl9170_debugfs_unregister(struct ar9170 *ar) 880 { 881 debugfs_remove_recursive(ar->debug_dir); 882 } 883