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