1 /* 2 * Copyright (c) 2004-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 "core.h" 18 19 #include <linux/circ_buf.h> 20 #include <linux/fs.h> 21 #include <linux/vmalloc.h> 22 23 #include "debug.h" 24 #include "target.h" 25 26 struct ath6kl_fwlog_slot { 27 __le32 timestamp; 28 __le32 length; 29 30 /* max ATH6KL_FWLOG_PAYLOAD_SIZE bytes */ 31 u8 payload[0]; 32 }; 33 34 #define ATH6KL_FWLOG_SIZE 32768 35 #define ATH6KL_FWLOG_SLOT_SIZE (sizeof(struct ath6kl_fwlog_slot) + \ 36 ATH6KL_FWLOG_PAYLOAD_SIZE) 37 #define ATH6KL_FWLOG_VALID_MASK 0x1ffff 38 39 int ath6kl_printk(const char *level, const char *fmt, ...) 40 { 41 struct va_format vaf; 42 va_list args; 43 int rtn; 44 45 va_start(args, fmt); 46 47 vaf.fmt = fmt; 48 vaf.va = &args; 49 50 rtn = printk("%sath6kl: %pV", level, &vaf); 51 52 va_end(args); 53 54 return rtn; 55 } 56 57 #ifdef CONFIG_ATH6KL_DEBUG 58 59 #define REG_OUTPUT_LEN_PER_LINE 25 60 #define REGTYPE_STR_LEN 100 61 62 struct ath6kl_diag_reg_info { 63 u32 reg_start; 64 u32 reg_end; 65 const char *reg_info; 66 }; 67 68 static const struct ath6kl_diag_reg_info diag_reg[] = { 69 { 0x20000, 0x200fc, "General DMA and Rx registers" }, 70 { 0x28000, 0x28900, "MAC PCU register & keycache" }, 71 { 0x20800, 0x20a40, "QCU" }, 72 { 0x21000, 0x212f0, "DCU" }, 73 { 0x4000, 0x42e4, "RTC" }, 74 { 0x540000, 0x540000 + (256 * 1024), "RAM" }, 75 { 0x29800, 0x2B210, "Base Band" }, 76 { 0x1C000, 0x1C748, "Analog" }, 77 }; 78 79 void ath6kl_dump_registers(struct ath6kl_device *dev, 80 struct ath6kl_irq_proc_registers *irq_proc_reg, 81 struct ath6kl_irq_enable_reg *irq_enable_reg) 82 { 83 84 ath6kl_dbg(ATH6KL_DBG_ANY, ("<------- Register Table -------->\n")); 85 86 if (irq_proc_reg != NULL) { 87 ath6kl_dbg(ATH6KL_DBG_ANY, 88 "Host Int status: 0x%x\n", 89 irq_proc_reg->host_int_status); 90 ath6kl_dbg(ATH6KL_DBG_ANY, 91 "CPU Int status: 0x%x\n", 92 irq_proc_reg->cpu_int_status); 93 ath6kl_dbg(ATH6KL_DBG_ANY, 94 "Error Int status: 0x%x\n", 95 irq_proc_reg->error_int_status); 96 ath6kl_dbg(ATH6KL_DBG_ANY, 97 "Counter Int status: 0x%x\n", 98 irq_proc_reg->counter_int_status); 99 ath6kl_dbg(ATH6KL_DBG_ANY, 100 "Mbox Frame: 0x%x\n", 101 irq_proc_reg->mbox_frame); 102 ath6kl_dbg(ATH6KL_DBG_ANY, 103 "Rx Lookahead Valid: 0x%x\n", 104 irq_proc_reg->rx_lkahd_valid); 105 ath6kl_dbg(ATH6KL_DBG_ANY, 106 "Rx Lookahead 0: 0x%x\n", 107 irq_proc_reg->rx_lkahd[0]); 108 ath6kl_dbg(ATH6KL_DBG_ANY, 109 "Rx Lookahead 1: 0x%x\n", 110 irq_proc_reg->rx_lkahd[1]); 111 112 if (dev->ar->mbox_info.gmbox_addr != 0) { 113 /* 114 * If the target supports GMBOX hardware, dump some 115 * additional state. 116 */ 117 ath6kl_dbg(ATH6KL_DBG_ANY, 118 "GMBOX Host Int status 2: 0x%x\n", 119 irq_proc_reg->host_int_status2); 120 ath6kl_dbg(ATH6KL_DBG_ANY, 121 "GMBOX RX Avail: 0x%x\n", 122 irq_proc_reg->gmbox_rx_avail); 123 ath6kl_dbg(ATH6KL_DBG_ANY, 124 "GMBOX lookahead alias 0: 0x%x\n", 125 irq_proc_reg->rx_gmbox_lkahd_alias[0]); 126 ath6kl_dbg(ATH6KL_DBG_ANY, 127 "GMBOX lookahead alias 1: 0x%x\n", 128 irq_proc_reg->rx_gmbox_lkahd_alias[1]); 129 } 130 131 } 132 133 if (irq_enable_reg != NULL) { 134 ath6kl_dbg(ATH6KL_DBG_ANY, 135 "Int status Enable: 0x%x\n", 136 irq_enable_reg->int_status_en); 137 ath6kl_dbg(ATH6KL_DBG_ANY, "Counter Int status Enable: 0x%x\n", 138 irq_enable_reg->cntr_int_status_en); 139 } 140 ath6kl_dbg(ATH6KL_DBG_ANY, "<------------------------------->\n"); 141 } 142 143 static void dump_cred_dist(struct htc_endpoint_credit_dist *ep_dist) 144 { 145 ath6kl_dbg(ATH6KL_DBG_ANY, 146 "--- endpoint: %d svc_id: 0x%X ---\n", 147 ep_dist->endpoint, ep_dist->svc_id); 148 ath6kl_dbg(ATH6KL_DBG_ANY, " dist_flags : 0x%X\n", 149 ep_dist->dist_flags); 150 ath6kl_dbg(ATH6KL_DBG_ANY, " cred_norm : %d\n", 151 ep_dist->cred_norm); 152 ath6kl_dbg(ATH6KL_DBG_ANY, " cred_min : %d\n", 153 ep_dist->cred_min); 154 ath6kl_dbg(ATH6KL_DBG_ANY, " credits : %d\n", 155 ep_dist->credits); 156 ath6kl_dbg(ATH6KL_DBG_ANY, " cred_assngd : %d\n", 157 ep_dist->cred_assngd); 158 ath6kl_dbg(ATH6KL_DBG_ANY, " seek_cred : %d\n", 159 ep_dist->seek_cred); 160 ath6kl_dbg(ATH6KL_DBG_ANY, " cred_sz : %d\n", 161 ep_dist->cred_sz); 162 ath6kl_dbg(ATH6KL_DBG_ANY, " cred_per_msg : %d\n", 163 ep_dist->cred_per_msg); 164 ath6kl_dbg(ATH6KL_DBG_ANY, " cred_to_dist : %d\n", 165 ep_dist->cred_to_dist); 166 ath6kl_dbg(ATH6KL_DBG_ANY, " txq_depth : %d\n", 167 get_queue_depth(&((struct htc_endpoint *) 168 ep_dist->htc_rsvd)->txq)); 169 ath6kl_dbg(ATH6KL_DBG_ANY, 170 "----------------------------------\n"); 171 } 172 173 void dump_cred_dist_stats(struct htc_target *target) 174 { 175 struct htc_endpoint_credit_dist *ep_list; 176 177 if (!AR_DBG_LVL_CHECK(ATH6KL_DBG_TRC)) 178 return; 179 180 list_for_each_entry(ep_list, &target->cred_dist_list, list) 181 dump_cred_dist(ep_list); 182 183 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "ctxt:%p dist:%p\n", 184 target->cred_dist_cntxt, NULL); 185 ath6kl_dbg(ATH6KL_DBG_TRC, "credit distribution, total : %d, free : %d\n", 186 target->cred_dist_cntxt->total_avail_credits, 187 target->cred_dist_cntxt->cur_free_credits); 188 } 189 190 static int ath6kl_debugfs_open(struct inode *inode, struct file *file) 191 { 192 file->private_data = inode->i_private; 193 return 0; 194 } 195 196 void ath6kl_debug_war(struct ath6kl *ar, enum ath6kl_war war) 197 { 198 switch (war) { 199 case ATH6KL_WAR_INVALID_RATE: 200 ar->debug.war_stats.invalid_rate++; 201 break; 202 } 203 } 204 205 static ssize_t read_file_war_stats(struct file *file, char __user *user_buf, 206 size_t count, loff_t *ppos) 207 { 208 struct ath6kl *ar = file->private_data; 209 char *buf; 210 unsigned int len = 0, buf_len = 1500; 211 ssize_t ret_cnt; 212 213 buf = kzalloc(buf_len, GFP_KERNEL); 214 if (!buf) 215 return -ENOMEM; 216 217 len += scnprintf(buf + len, buf_len - len, "\n"); 218 len += scnprintf(buf + len, buf_len - len, "%25s\n", 219 "Workaround stats"); 220 len += scnprintf(buf + len, buf_len - len, "%25s\n\n", 221 "================="); 222 len += scnprintf(buf + len, buf_len - len, "%20s %10u\n", 223 "Invalid rates", ar->debug.war_stats.invalid_rate); 224 225 if (WARN_ON(len > buf_len)) 226 len = buf_len; 227 228 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len); 229 230 kfree(buf); 231 return ret_cnt; 232 } 233 234 static const struct file_operations fops_war_stats = { 235 .read = read_file_war_stats, 236 .open = ath6kl_debugfs_open, 237 .owner = THIS_MODULE, 238 .llseek = default_llseek, 239 }; 240 241 static void ath6kl_debug_fwlog_add(struct ath6kl *ar, const void *buf, 242 size_t buf_len) 243 { 244 struct circ_buf *fwlog = &ar->debug.fwlog_buf; 245 size_t space; 246 int i; 247 248 /* entries must all be equal size */ 249 if (WARN_ON(buf_len != ATH6KL_FWLOG_SLOT_SIZE)) 250 return; 251 252 space = CIRC_SPACE(fwlog->head, fwlog->tail, ATH6KL_FWLOG_SIZE); 253 if (space < buf_len) 254 /* discard oldest slot */ 255 fwlog->tail = (fwlog->tail + ATH6KL_FWLOG_SLOT_SIZE) & 256 (ATH6KL_FWLOG_SIZE - 1); 257 258 for (i = 0; i < buf_len; i += space) { 259 space = CIRC_SPACE_TO_END(fwlog->head, fwlog->tail, 260 ATH6KL_FWLOG_SIZE); 261 262 if ((size_t) space > buf_len - i) 263 space = buf_len - i; 264 265 memcpy(&fwlog->buf[fwlog->head], buf, space); 266 fwlog->head = (fwlog->head + space) & (ATH6KL_FWLOG_SIZE - 1); 267 } 268 269 } 270 271 void ath6kl_debug_fwlog_event(struct ath6kl *ar, const void *buf, size_t len) 272 { 273 struct ath6kl_fwlog_slot *slot = ar->debug.fwlog_tmp; 274 size_t slot_len; 275 276 if (WARN_ON(len > ATH6KL_FWLOG_PAYLOAD_SIZE)) 277 return; 278 279 spin_lock_bh(&ar->debug.fwlog_lock); 280 281 slot->timestamp = cpu_to_le32(jiffies); 282 slot->length = cpu_to_le32(len); 283 memcpy(slot->payload, buf, len); 284 285 slot_len = sizeof(*slot) + len; 286 287 if (slot_len < ATH6KL_FWLOG_SLOT_SIZE) 288 memset(slot->payload + len, 0, 289 ATH6KL_FWLOG_SLOT_SIZE - slot_len); 290 291 ath6kl_debug_fwlog_add(ar, slot, ATH6KL_FWLOG_SLOT_SIZE); 292 293 spin_unlock_bh(&ar->debug.fwlog_lock); 294 } 295 296 static bool ath6kl_debug_fwlog_empty(struct ath6kl *ar) 297 { 298 return CIRC_CNT(ar->debug.fwlog_buf.head, 299 ar->debug.fwlog_buf.tail, 300 ATH6KL_FWLOG_SLOT_SIZE) == 0; 301 } 302 303 static ssize_t ath6kl_fwlog_read(struct file *file, char __user *user_buf, 304 size_t count, loff_t *ppos) 305 { 306 struct ath6kl *ar = file->private_data; 307 struct circ_buf *fwlog = &ar->debug.fwlog_buf; 308 size_t len = 0, buf_len = count; 309 ssize_t ret_cnt; 310 char *buf; 311 int ccnt; 312 313 buf = vmalloc(buf_len); 314 if (!buf) 315 return -ENOMEM; 316 317 /* read undelivered logs from firmware */ 318 ath6kl_read_fwlogs(ar); 319 320 spin_lock_bh(&ar->debug.fwlog_lock); 321 322 while (len < buf_len && !ath6kl_debug_fwlog_empty(ar)) { 323 ccnt = CIRC_CNT_TO_END(fwlog->head, fwlog->tail, 324 ATH6KL_FWLOG_SIZE); 325 326 if ((size_t) ccnt > buf_len - len) 327 ccnt = buf_len - len; 328 329 memcpy(buf + len, &fwlog->buf[fwlog->tail], ccnt); 330 len += ccnt; 331 332 fwlog->tail = (fwlog->tail + ccnt) & 333 (ATH6KL_FWLOG_SIZE - 1); 334 } 335 336 spin_unlock_bh(&ar->debug.fwlog_lock); 337 338 if (WARN_ON(len > buf_len)) 339 len = buf_len; 340 341 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len); 342 343 vfree(buf); 344 345 return ret_cnt; 346 } 347 348 static const struct file_operations fops_fwlog = { 349 .open = ath6kl_debugfs_open, 350 .read = ath6kl_fwlog_read, 351 .owner = THIS_MODULE, 352 .llseek = default_llseek, 353 }; 354 355 static ssize_t ath6kl_fwlog_mask_read(struct file *file, char __user *user_buf, 356 size_t count, loff_t *ppos) 357 { 358 struct ath6kl *ar = file->private_data; 359 char buf[16]; 360 int len; 361 362 len = snprintf(buf, sizeof(buf), "0x%x\n", ar->debug.fwlog_mask); 363 364 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 365 } 366 367 static ssize_t ath6kl_fwlog_mask_write(struct file *file, 368 const char __user *user_buf, 369 size_t count, loff_t *ppos) 370 { 371 struct ath6kl *ar = file->private_data; 372 int ret; 373 374 ret = kstrtou32_from_user(user_buf, count, 0, &ar->debug.fwlog_mask); 375 if (ret) 376 return ret; 377 378 ret = ath6kl_wmi_config_debug_module_cmd(ar->wmi, 379 ATH6KL_FWLOG_VALID_MASK, 380 ar->debug.fwlog_mask); 381 if (ret) 382 return ret; 383 384 return count; 385 } 386 387 static const struct file_operations fops_fwlog_mask = { 388 .open = ath6kl_debugfs_open, 389 .read = ath6kl_fwlog_mask_read, 390 .write = ath6kl_fwlog_mask_write, 391 .owner = THIS_MODULE, 392 .llseek = default_llseek, 393 }; 394 395 static ssize_t read_file_tgt_stats(struct file *file, char __user *user_buf, 396 size_t count, loff_t *ppos) 397 { 398 struct ath6kl *ar = file->private_data; 399 struct target_stats *tgt_stats = &ar->target_stats; 400 char *buf; 401 unsigned int len = 0, buf_len = 1500; 402 int i; 403 long left; 404 ssize_t ret_cnt; 405 406 buf = kzalloc(buf_len, GFP_KERNEL); 407 if (!buf) 408 return -ENOMEM; 409 410 if (down_interruptible(&ar->sem)) { 411 kfree(buf); 412 return -EBUSY; 413 } 414 415 set_bit(STATS_UPDATE_PEND, &ar->flag); 416 417 if (ath6kl_wmi_get_stats_cmd(ar->wmi)) { 418 up(&ar->sem); 419 kfree(buf); 420 return -EIO; 421 } 422 423 left = wait_event_interruptible_timeout(ar->event_wq, 424 !test_bit(STATS_UPDATE_PEND, 425 &ar->flag), WMI_TIMEOUT); 426 427 up(&ar->sem); 428 429 if (left <= 0) { 430 kfree(buf); 431 return -ETIMEDOUT; 432 } 433 434 len += scnprintf(buf + len, buf_len - len, "\n"); 435 len += scnprintf(buf + len, buf_len - len, "%25s\n", 436 "Target Tx stats"); 437 len += scnprintf(buf + len, buf_len - len, "%25s\n\n", 438 "================="); 439 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 440 "Ucast packets", tgt_stats->tx_ucast_pkt); 441 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 442 "Bcast packets", tgt_stats->tx_bcast_pkt); 443 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 444 "Ucast byte", tgt_stats->tx_ucast_byte); 445 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 446 "Bcast byte", tgt_stats->tx_bcast_byte); 447 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 448 "Rts success cnt", tgt_stats->tx_rts_success_cnt); 449 for (i = 0; i < 4; i++) 450 len += scnprintf(buf + len, buf_len - len, 451 "%18s %d %10llu\n", "PER on ac", 452 i, tgt_stats->tx_pkt_per_ac[i]); 453 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 454 "Error", tgt_stats->tx_err); 455 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 456 "Fail count", tgt_stats->tx_fail_cnt); 457 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 458 "Retry count", tgt_stats->tx_retry_cnt); 459 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 460 "Multi retry cnt", tgt_stats->tx_mult_retry_cnt); 461 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 462 "Rts fail cnt", tgt_stats->tx_rts_fail_cnt); 463 len += scnprintf(buf + len, buf_len - len, "%25s %10llu\n\n", 464 "TKIP counter measure used", 465 tgt_stats->tkip_cnter_measures_invoked); 466 467 len += scnprintf(buf + len, buf_len - len, "%25s\n", 468 "Target Rx stats"); 469 len += scnprintf(buf + len, buf_len - len, "%25s\n", 470 "================="); 471 472 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 473 "Ucast packets", tgt_stats->rx_ucast_pkt); 474 len += scnprintf(buf + len, buf_len - len, "%20s %10d\n", 475 "Ucast Rate", tgt_stats->rx_ucast_rate); 476 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 477 "Bcast packets", tgt_stats->rx_bcast_pkt); 478 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 479 "Ucast byte", tgt_stats->rx_ucast_byte); 480 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 481 "Bcast byte", tgt_stats->rx_bcast_byte); 482 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 483 "Fragmented pkt", tgt_stats->rx_frgment_pkt); 484 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 485 "Error", tgt_stats->rx_err); 486 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 487 "CRC Err", tgt_stats->rx_crc_err); 488 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 489 "Key chache miss", tgt_stats->rx_key_cache_miss); 490 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 491 "Decrypt Err", tgt_stats->rx_decrypt_err); 492 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 493 "Duplicate frame", tgt_stats->rx_dupl_frame); 494 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 495 "Tkip Mic failure", tgt_stats->tkip_local_mic_fail); 496 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 497 "TKIP format err", tgt_stats->tkip_fmt_err); 498 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 499 "CCMP format Err", tgt_stats->ccmp_fmt_err); 500 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n\n", 501 "CCMP Replay Err", tgt_stats->ccmp_replays); 502 503 len += scnprintf(buf + len, buf_len - len, "%25s\n", 504 "Misc Target stats"); 505 len += scnprintf(buf + len, buf_len - len, "%25s\n", 506 "================="); 507 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 508 "Beacon Miss count", tgt_stats->cs_bmiss_cnt); 509 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 510 "Num Connects", tgt_stats->cs_connect_cnt); 511 len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n", 512 "Num disconnects", tgt_stats->cs_discon_cnt); 513 len += scnprintf(buf + len, buf_len - len, "%20s %10d\n", 514 "Beacon avg rssi", tgt_stats->cs_ave_beacon_rssi); 515 516 if (len > buf_len) 517 len = buf_len; 518 519 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len); 520 521 kfree(buf); 522 return ret_cnt; 523 } 524 525 static const struct file_operations fops_tgt_stats = { 526 .read = read_file_tgt_stats, 527 .open = ath6kl_debugfs_open, 528 .owner = THIS_MODULE, 529 .llseek = default_llseek, 530 }; 531 532 #define print_credit_info(fmt_str, ep_list_field) \ 533 (len += scnprintf(buf + len, buf_len - len, fmt_str, \ 534 ep_list->ep_list_field)) 535 #define CREDIT_INFO_DISPLAY_STRING_LEN 200 536 #define CREDIT_INFO_LEN 128 537 538 static ssize_t read_file_credit_dist_stats(struct file *file, 539 char __user *user_buf, 540 size_t count, loff_t *ppos) 541 { 542 struct ath6kl *ar = file->private_data; 543 struct htc_target *target = ar->htc_target; 544 struct htc_endpoint_credit_dist *ep_list; 545 char *buf; 546 unsigned int buf_len, len = 0; 547 ssize_t ret_cnt; 548 549 buf_len = CREDIT_INFO_DISPLAY_STRING_LEN + 550 get_queue_depth(&target->cred_dist_list) * CREDIT_INFO_LEN; 551 buf = kzalloc(buf_len, GFP_KERNEL); 552 if (!buf) 553 return -ENOMEM; 554 555 len += scnprintf(buf + len, buf_len - len, "%25s%5d\n", 556 "Total Avail Credits: ", 557 target->cred_dist_cntxt->total_avail_credits); 558 len += scnprintf(buf + len, buf_len - len, "%25s%5d\n", 559 "Free credits :", 560 target->cred_dist_cntxt->cur_free_credits); 561 562 len += scnprintf(buf + len, buf_len - len, 563 " Epid Flags Cred_norm Cred_min Credits Cred_assngd" 564 " Seek_cred Cred_sz Cred_per_msg Cred_to_dist" 565 " qdepth\n"); 566 567 list_for_each_entry(ep_list, &target->cred_dist_list, list) { 568 print_credit_info(" %2d", endpoint); 569 print_credit_info("%10x", dist_flags); 570 print_credit_info("%8d", cred_norm); 571 print_credit_info("%9d", cred_min); 572 print_credit_info("%9d", credits); 573 print_credit_info("%10d", cred_assngd); 574 print_credit_info("%13d", seek_cred); 575 print_credit_info("%12d", cred_sz); 576 print_credit_info("%9d", cred_per_msg); 577 print_credit_info("%14d", cred_to_dist); 578 len += scnprintf(buf + len, buf_len - len, "%12d\n", 579 get_queue_depth(&((struct htc_endpoint *) 580 ep_list->htc_rsvd)->txq)); 581 } 582 583 if (len > buf_len) 584 len = buf_len; 585 586 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len); 587 kfree(buf); 588 return ret_cnt; 589 } 590 591 static const struct file_operations fops_credit_dist_stats = { 592 .read = read_file_credit_dist_stats, 593 .open = ath6kl_debugfs_open, 594 .owner = THIS_MODULE, 595 .llseek = default_llseek, 596 }; 597 598 static unsigned int print_endpoint_stat(struct htc_target *target, char *buf, 599 unsigned int buf_len, unsigned int len, 600 int offset, const char *name) 601 { 602 int i; 603 struct htc_endpoint_stats *ep_st; 604 u32 *counter; 605 606 len += scnprintf(buf + len, buf_len - len, "%s:", name); 607 for (i = 0; i < ENDPOINT_MAX; i++) { 608 ep_st = &target->endpoint[i].ep_st; 609 counter = ((u32 *) ep_st) + (offset / 4); 610 len += scnprintf(buf + len, buf_len - len, " %u", *counter); 611 } 612 len += scnprintf(buf + len, buf_len - len, "\n"); 613 614 return len; 615 } 616 617 static ssize_t ath6kl_endpoint_stats_read(struct file *file, 618 char __user *user_buf, 619 size_t count, loff_t *ppos) 620 { 621 struct ath6kl *ar = file->private_data; 622 struct htc_target *target = ar->htc_target; 623 char *buf; 624 unsigned int buf_len, len = 0; 625 ssize_t ret_cnt; 626 627 buf_len = 1000 + ENDPOINT_MAX * 100; 628 buf = kzalloc(buf_len, GFP_KERNEL); 629 if (!buf) 630 return -ENOMEM; 631 632 #define EPSTAT(name) \ 633 len = print_endpoint_stat(target, buf, buf_len, len, \ 634 offsetof(struct htc_endpoint_stats, name), \ 635 #name) 636 EPSTAT(cred_low_indicate); 637 EPSTAT(tx_issued); 638 EPSTAT(tx_pkt_bundled); 639 EPSTAT(tx_bundles); 640 EPSTAT(tx_dropped); 641 EPSTAT(tx_cred_rpt); 642 EPSTAT(cred_rpt_from_rx); 643 EPSTAT(cred_rpt_ep0); 644 EPSTAT(cred_from_rx); 645 EPSTAT(cred_from_other); 646 EPSTAT(cred_from_ep0); 647 EPSTAT(cred_cosumd); 648 EPSTAT(cred_retnd); 649 EPSTAT(rx_pkts); 650 EPSTAT(rx_lkahds); 651 EPSTAT(rx_bundl); 652 EPSTAT(rx_bundle_lkahd); 653 EPSTAT(rx_bundle_from_hdr); 654 EPSTAT(rx_alloc_thresh_hit); 655 EPSTAT(rxalloc_thresh_byte); 656 #undef EPSTAT 657 658 if (len > buf_len) 659 len = buf_len; 660 661 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len); 662 kfree(buf); 663 return ret_cnt; 664 } 665 666 static ssize_t ath6kl_endpoint_stats_write(struct file *file, 667 const char __user *user_buf, 668 size_t count, loff_t *ppos) 669 { 670 struct ath6kl *ar = file->private_data; 671 struct htc_target *target = ar->htc_target; 672 int ret, i; 673 u32 val; 674 struct htc_endpoint_stats *ep_st; 675 676 ret = kstrtou32_from_user(user_buf, count, 0, &val); 677 if (ret) 678 return ret; 679 if (val == 0) { 680 for (i = 0; i < ENDPOINT_MAX; i++) { 681 ep_st = &target->endpoint[i].ep_st; 682 memset(ep_st, 0, sizeof(*ep_st)); 683 } 684 } 685 686 return count; 687 } 688 689 static const struct file_operations fops_endpoint_stats = { 690 .open = ath6kl_debugfs_open, 691 .read = ath6kl_endpoint_stats_read, 692 .write = ath6kl_endpoint_stats_write, 693 .owner = THIS_MODULE, 694 .llseek = default_llseek, 695 }; 696 697 static unsigned long ath6kl_get_num_reg(void) 698 { 699 int i; 700 unsigned long n_reg = 0; 701 702 for (i = 0; i < ARRAY_SIZE(diag_reg); i++) 703 n_reg = n_reg + 704 (diag_reg[i].reg_end - diag_reg[i].reg_start) / 4 + 1; 705 706 return n_reg; 707 } 708 709 static bool ath6kl_dbg_is_diag_reg_valid(u32 reg_addr) 710 { 711 int i; 712 713 for (i = 0; i < ARRAY_SIZE(diag_reg); i++) { 714 if (reg_addr >= diag_reg[i].reg_start && 715 reg_addr <= diag_reg[i].reg_end) 716 return true; 717 } 718 719 return false; 720 } 721 722 static ssize_t ath6kl_regread_read(struct file *file, char __user *user_buf, 723 size_t count, loff_t *ppos) 724 { 725 struct ath6kl *ar = file->private_data; 726 u8 buf[50]; 727 unsigned int len = 0; 728 729 if (ar->debug.dbgfs_diag_reg) 730 len += scnprintf(buf + len, sizeof(buf) - len, "0x%x\n", 731 ar->debug.dbgfs_diag_reg); 732 else 733 len += scnprintf(buf + len, sizeof(buf) - len, 734 "All diag registers\n"); 735 736 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 737 } 738 739 static ssize_t ath6kl_regread_write(struct file *file, 740 const char __user *user_buf, 741 size_t count, loff_t *ppos) 742 { 743 struct ath6kl *ar = file->private_data; 744 u8 buf[50]; 745 unsigned int len; 746 unsigned long reg_addr; 747 748 len = min(count, sizeof(buf) - 1); 749 if (copy_from_user(buf, user_buf, len)) 750 return -EFAULT; 751 752 buf[len] = '\0'; 753 754 if (strict_strtoul(buf, 0, ®_addr)) 755 return -EINVAL; 756 757 if ((reg_addr % 4) != 0) 758 return -EINVAL; 759 760 if (reg_addr && !ath6kl_dbg_is_diag_reg_valid(reg_addr)) 761 return -EINVAL; 762 763 ar->debug.dbgfs_diag_reg = reg_addr; 764 765 return count; 766 } 767 768 static const struct file_operations fops_diag_reg_read = { 769 .read = ath6kl_regread_read, 770 .write = ath6kl_regread_write, 771 .open = ath6kl_debugfs_open, 772 .owner = THIS_MODULE, 773 .llseek = default_llseek, 774 }; 775 776 static int ath6kl_regdump_open(struct inode *inode, struct file *file) 777 { 778 struct ath6kl *ar = inode->i_private; 779 u8 *buf; 780 unsigned long int reg_len; 781 unsigned int len = 0, n_reg; 782 u32 addr; 783 __le32 reg_val; 784 int i, status; 785 786 /* Dump all the registers if no register is specified */ 787 if (!ar->debug.dbgfs_diag_reg) 788 n_reg = ath6kl_get_num_reg(); 789 else 790 n_reg = 1; 791 792 reg_len = n_reg * REG_OUTPUT_LEN_PER_LINE; 793 if (n_reg > 1) 794 reg_len += REGTYPE_STR_LEN; 795 796 buf = vmalloc(reg_len); 797 if (!buf) 798 return -ENOMEM; 799 800 if (n_reg == 1) { 801 addr = ar->debug.dbgfs_diag_reg; 802 803 status = ath6kl_diag_read32(ar, 804 TARG_VTOP(ar->target_type, addr), 805 (u32 *)®_val); 806 if (status) 807 goto fail_reg_read; 808 809 len += scnprintf(buf + len, reg_len - len, 810 "0x%06x 0x%08x\n", addr, le32_to_cpu(reg_val)); 811 goto done; 812 } 813 814 for (i = 0; i < ARRAY_SIZE(diag_reg); i++) { 815 len += scnprintf(buf + len, reg_len - len, 816 "%s\n", diag_reg[i].reg_info); 817 for (addr = diag_reg[i].reg_start; 818 addr <= diag_reg[i].reg_end; addr += 4) { 819 status = ath6kl_diag_read32(ar, 820 TARG_VTOP(ar->target_type, addr), 821 (u32 *)®_val); 822 if (status) 823 goto fail_reg_read; 824 825 len += scnprintf(buf + len, reg_len - len, 826 "0x%06x 0x%08x\n", 827 addr, le32_to_cpu(reg_val)); 828 } 829 } 830 831 done: 832 file->private_data = buf; 833 return 0; 834 835 fail_reg_read: 836 ath6kl_warn("Unable to read memory:%u\n", addr); 837 vfree(buf); 838 return -EIO; 839 } 840 841 static ssize_t ath6kl_regdump_read(struct file *file, char __user *user_buf, 842 size_t count, loff_t *ppos) 843 { 844 u8 *buf = file->private_data; 845 return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf)); 846 } 847 848 static int ath6kl_regdump_release(struct inode *inode, struct file *file) 849 { 850 vfree(file->private_data); 851 return 0; 852 } 853 854 static const struct file_operations fops_reg_dump = { 855 .open = ath6kl_regdump_open, 856 .read = ath6kl_regdump_read, 857 .release = ath6kl_regdump_release, 858 .owner = THIS_MODULE, 859 .llseek = default_llseek, 860 }; 861 862 static ssize_t ath6kl_lrssi_roam_write(struct file *file, 863 const char __user *user_buf, 864 size_t count, loff_t *ppos) 865 { 866 struct ath6kl *ar = file->private_data; 867 unsigned long lrssi_roam_threshold; 868 char buf[32]; 869 ssize_t len; 870 871 len = min(count, sizeof(buf) - 1); 872 if (copy_from_user(buf, user_buf, len)) 873 return -EFAULT; 874 875 buf[len] = '\0'; 876 if (strict_strtoul(buf, 0, &lrssi_roam_threshold)) 877 return -EINVAL; 878 879 ar->lrssi_roam_threshold = lrssi_roam_threshold; 880 881 ath6kl_wmi_set_roam_lrssi_cmd(ar->wmi, ar->lrssi_roam_threshold); 882 883 return count; 884 } 885 886 static ssize_t ath6kl_lrssi_roam_read(struct file *file, 887 char __user *user_buf, 888 size_t count, loff_t *ppos) 889 { 890 struct ath6kl *ar = file->private_data; 891 char buf[32]; 892 unsigned int len; 893 894 len = snprintf(buf, sizeof(buf), "%u\n", ar->lrssi_roam_threshold); 895 896 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 897 } 898 899 static const struct file_operations fops_lrssi_roam_threshold = { 900 .read = ath6kl_lrssi_roam_read, 901 .write = ath6kl_lrssi_roam_write, 902 .open = ath6kl_debugfs_open, 903 .owner = THIS_MODULE, 904 .llseek = default_llseek, 905 }; 906 907 static ssize_t ath6kl_regwrite_read(struct file *file, 908 char __user *user_buf, 909 size_t count, loff_t *ppos) 910 { 911 struct ath6kl *ar = file->private_data; 912 u8 buf[32]; 913 unsigned int len = 0; 914 915 len = scnprintf(buf, sizeof(buf), "Addr: 0x%x Val: 0x%x\n", 916 ar->debug.diag_reg_addr_wr, ar->debug.diag_reg_val_wr); 917 918 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 919 } 920 921 static ssize_t ath6kl_regwrite_write(struct file *file, 922 const char __user *user_buf, 923 size_t count, loff_t *ppos) 924 { 925 struct ath6kl *ar = file->private_data; 926 char buf[32]; 927 char *sptr, *token; 928 unsigned int len = 0; 929 u32 reg_addr, reg_val; 930 931 len = min(count, sizeof(buf) - 1); 932 if (copy_from_user(buf, user_buf, len)) 933 return -EFAULT; 934 935 buf[len] = '\0'; 936 sptr = buf; 937 938 token = strsep(&sptr, "="); 939 if (!token) 940 return -EINVAL; 941 942 if (kstrtou32(token, 0, ®_addr)) 943 return -EINVAL; 944 945 if (!ath6kl_dbg_is_diag_reg_valid(reg_addr)) 946 return -EINVAL; 947 948 if (kstrtou32(sptr, 0, ®_val)) 949 return -EINVAL; 950 951 ar->debug.diag_reg_addr_wr = reg_addr; 952 ar->debug.diag_reg_val_wr = reg_val; 953 954 if (ath6kl_diag_write32(ar, ar->debug.diag_reg_addr_wr, 955 cpu_to_le32(ar->debug.diag_reg_val_wr))) 956 return -EIO; 957 958 return count; 959 } 960 961 static const struct file_operations fops_diag_reg_write = { 962 .read = ath6kl_regwrite_read, 963 .write = ath6kl_regwrite_write, 964 .open = ath6kl_debugfs_open, 965 .owner = THIS_MODULE, 966 .llseek = default_llseek, 967 }; 968 969 int ath6kl_debug_roam_tbl_event(struct ath6kl *ar, const void *buf, 970 size_t len) 971 { 972 const struct wmi_target_roam_tbl *tbl; 973 u16 num_entries; 974 975 if (len < sizeof(*tbl)) 976 return -EINVAL; 977 978 tbl = (const struct wmi_target_roam_tbl *) buf; 979 num_entries = le16_to_cpu(tbl->num_entries); 980 if (sizeof(*tbl) + num_entries * sizeof(struct wmi_bss_roam_info) > 981 len) 982 return -EINVAL; 983 984 if (ar->debug.roam_tbl == NULL || 985 ar->debug.roam_tbl_len < (unsigned int) len) { 986 kfree(ar->debug.roam_tbl); 987 ar->debug.roam_tbl = kmalloc(len, GFP_ATOMIC); 988 if (ar->debug.roam_tbl == NULL) 989 return -ENOMEM; 990 } 991 992 memcpy(ar->debug.roam_tbl, buf, len); 993 ar->debug.roam_tbl_len = len; 994 995 if (test_bit(ROAM_TBL_PEND, &ar->flag)) { 996 clear_bit(ROAM_TBL_PEND, &ar->flag); 997 wake_up(&ar->event_wq); 998 } 999 1000 return 0; 1001 } 1002 1003 static ssize_t ath6kl_roam_table_read(struct file *file, char __user *user_buf, 1004 size_t count, loff_t *ppos) 1005 { 1006 struct ath6kl *ar = file->private_data; 1007 int ret; 1008 long left; 1009 struct wmi_target_roam_tbl *tbl; 1010 u16 num_entries, i; 1011 char *buf; 1012 unsigned int len, buf_len; 1013 ssize_t ret_cnt; 1014 1015 if (down_interruptible(&ar->sem)) 1016 return -EBUSY; 1017 1018 set_bit(ROAM_TBL_PEND, &ar->flag); 1019 1020 ret = ath6kl_wmi_get_roam_tbl_cmd(ar->wmi); 1021 if (ret) { 1022 up(&ar->sem); 1023 return ret; 1024 } 1025 1026 left = wait_event_interruptible_timeout( 1027 ar->event_wq, !test_bit(ROAM_TBL_PEND, &ar->flag), WMI_TIMEOUT); 1028 up(&ar->sem); 1029 1030 if (left <= 0) 1031 return -ETIMEDOUT; 1032 1033 if (ar->debug.roam_tbl == NULL) 1034 return -ENOMEM; 1035 1036 tbl = (struct wmi_target_roam_tbl *) ar->debug.roam_tbl; 1037 num_entries = le16_to_cpu(tbl->num_entries); 1038 1039 buf_len = 100 + num_entries * 100; 1040 buf = kzalloc(buf_len, GFP_KERNEL); 1041 if (buf == NULL) 1042 return -ENOMEM; 1043 len = 0; 1044 len += scnprintf(buf + len, buf_len - len, 1045 "roam_mode=%u\n\n" 1046 "# roam_util bssid rssi rssidt last_rssi util bias\n", 1047 le16_to_cpu(tbl->roam_mode)); 1048 1049 for (i = 0; i < num_entries; i++) { 1050 struct wmi_bss_roam_info *info = &tbl->info[i]; 1051 len += scnprintf(buf + len, buf_len - len, 1052 "%d %pM %d %d %d %d %d\n", 1053 a_sle32_to_cpu(info->roam_util), info->bssid, 1054 info->rssi, info->rssidt, info->last_rssi, 1055 info->util, info->bias); 1056 } 1057 1058 if (len > buf_len) 1059 len = buf_len; 1060 1061 ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len); 1062 1063 kfree(buf); 1064 return ret_cnt; 1065 } 1066 1067 static const struct file_operations fops_roam_table = { 1068 .read = ath6kl_roam_table_read, 1069 .open = ath6kl_debugfs_open, 1070 .owner = THIS_MODULE, 1071 .llseek = default_llseek, 1072 }; 1073 1074 int ath6kl_debug_init(struct ath6kl *ar) 1075 { 1076 ar->debug.fwlog_buf.buf = vmalloc(ATH6KL_FWLOG_SIZE); 1077 if (ar->debug.fwlog_buf.buf == NULL) 1078 return -ENOMEM; 1079 1080 ar->debug.fwlog_tmp = kmalloc(ATH6KL_FWLOG_SLOT_SIZE, GFP_KERNEL); 1081 if (ar->debug.fwlog_tmp == NULL) { 1082 vfree(ar->debug.fwlog_buf.buf); 1083 return -ENOMEM; 1084 } 1085 1086 spin_lock_init(&ar->debug.fwlog_lock); 1087 1088 /* 1089 * Actually we are lying here but don't know how to read the mask 1090 * value from the firmware. 1091 */ 1092 ar->debug.fwlog_mask = 0; 1093 1094 ar->debugfs_phy = debugfs_create_dir("ath6kl", 1095 ar->wdev->wiphy->debugfsdir); 1096 if (!ar->debugfs_phy) { 1097 vfree(ar->debug.fwlog_buf.buf); 1098 kfree(ar->debug.fwlog_tmp); 1099 return -ENOMEM; 1100 } 1101 1102 debugfs_create_file("tgt_stats", S_IRUSR, ar->debugfs_phy, ar, 1103 &fops_tgt_stats); 1104 1105 debugfs_create_file("credit_dist_stats", S_IRUSR, ar->debugfs_phy, ar, 1106 &fops_credit_dist_stats); 1107 1108 debugfs_create_file("endpoint_stats", S_IRUSR | S_IWUSR, 1109 ar->debugfs_phy, ar, &fops_endpoint_stats); 1110 1111 debugfs_create_file("fwlog", S_IRUSR, ar->debugfs_phy, ar, 1112 &fops_fwlog); 1113 1114 debugfs_create_file("fwlog_mask", S_IRUSR | S_IWUSR, ar->debugfs_phy, 1115 ar, &fops_fwlog_mask); 1116 1117 debugfs_create_file("reg_addr", S_IRUSR | S_IWUSR, ar->debugfs_phy, ar, 1118 &fops_diag_reg_read); 1119 1120 debugfs_create_file("reg_dump", S_IRUSR, ar->debugfs_phy, ar, 1121 &fops_reg_dump); 1122 1123 debugfs_create_file("lrssi_roam_threshold", S_IRUSR | S_IWUSR, 1124 ar->debugfs_phy, ar, &fops_lrssi_roam_threshold); 1125 1126 debugfs_create_file("reg_write", S_IRUSR | S_IWUSR, 1127 ar->debugfs_phy, ar, &fops_diag_reg_write); 1128 1129 debugfs_create_file("war_stats", S_IRUSR, ar->debugfs_phy, ar, 1130 &fops_war_stats); 1131 1132 debugfs_create_file("roam_table", S_IRUSR, ar->debugfs_phy, ar, 1133 &fops_roam_table); 1134 1135 return 0; 1136 } 1137 1138 void ath6kl_debug_cleanup(struct ath6kl *ar) 1139 { 1140 vfree(ar->debug.fwlog_buf.buf); 1141 kfree(ar->debug.fwlog_tmp); 1142 kfree(ar->debug.roam_tbl); 1143 } 1144 1145 #endif 1146