drivers/net/wireless/ath/ath6kl/debug.c

   1 /*
   2  * Copyright (c) 2004-2011 Atheros Communications Inc.
   3  * Copyright (c) 2011-2012 Qualcomm Atheros, Inc.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #include "core.h"
  19
  20 #include <linux/skbuff.h>
  21 #include <linux/fs.h>
  22 #include <linux/vmalloc.h>
  23 #include <linux/export.h>
  24
  25 #include "debug.h"
  26 #include "target.h"
  27
  28 struct ath6kl_fwlog_slot {
  29         __le32 timestamp;
  30         __le32 length;
  31
  32         /* max ATH6KL_FWLOG_PAYLOAD_SIZE bytes */
  33         u8 payload[0];
  34 };
  35
  36 #define ATH6KL_FWLOG_MAX_ENTRIES 20
  37
  38 #define ATH6KL_FWLOG_VALID_MASK 0x1ffff
  39
  40 int ath6kl_printk(const char *level, const char *fmt, ...)
  41 {
  42         struct va_format vaf;
  43         va_list args;
  44         int rtn;
  45
  46         va_start(args, fmt);
  47
  48         vaf.fmt = fmt;
  49         vaf.va = &args;
  50
  51         rtn = printk("%sath6kl: %pV", level, &vaf);
  52
  53         va_end(args);
  54
  55         return rtn;
  56 }
  57 EXPORT_SYMBOL(ath6kl_printk);
  58
  59 #ifdef CONFIG_ATH6KL_DEBUG
  60
  61 void ath6kl_dbg(enum ATH6K_DEBUG_MASK mask, const char *fmt, ...)
  62 {
  63         struct va_format vaf;
  64         va_list args;
  65
  66         if (!(debug_mask & mask))
  67                 return;
  68
  69         va_start(args, fmt);
  70
  71         vaf.fmt = fmt;
  72         vaf.va = &args;
  73
  74         ath6kl_printk(KERN_DEBUG, "%pV", &vaf);
  75
  76         va_end(args);
  77 }
  78 EXPORT_SYMBOL(ath6kl_dbg);
  79
  80 void ath6kl_dbg_dump(enum ATH6K_DEBUG_MASK mask,
  81                      const char *msg, const char *prefix,
  82                      const void *buf, size_t len)
  83 {
  84         if (debug_mask & mask) {
  85                 if (msg)
  86                         ath6kl_dbg(mask, "%s\n", msg);
  87
  88                 print_hex_dump_bytes(prefix, DUMP_PREFIX_OFFSET, buf, len);
  89         }
  90 }
  91 EXPORT_SYMBOL(ath6kl_dbg_dump);
  92
  93 #define REG_OUTPUT_LEN_PER_LINE 25
  94 #define REGTYPE_STR_LEN         100
  95
  96 struct ath6kl_diag_reg_info {
  97         u32 reg_start;
  98         u32 reg_end;
  99         const char *reg_info;
 100 };
 101
 102 static const struct ath6kl_diag_reg_info diag_reg[] = {
 103         { 0x20000, 0x200fc, "General DMA and Rx registers" },
 104         { 0x28000, 0x28900, "MAC PCU register & keycache" },
 105         { 0x20800, 0x20a40, "QCU" },
 106         { 0x21000, 0x212f0, "DCU" },
 107         { 0x4000,  0x42e4, "RTC" },
 108         { 0x540000, 0x540000 + (256 * 1024), "RAM" },
 109         { 0x29800, 0x2B210, "Base Band" },
 110         { 0x1C000, 0x1C748, "Analog" },
 111 };
 112
 113 void ath6kl_dump_registers(struct ath6kl_device *dev,
 114                            struct ath6kl_irq_proc_registers *irq_proc_reg,
 115                            struct ath6kl_irq_enable_reg *irq_enable_reg)
 116 {
 117
 118         ath6kl_dbg(ATH6KL_DBG_IRQ, ("<------- Register Table -------->\n"));
 119
 120         if (irq_proc_reg != NULL) {
 121                 ath6kl_dbg(ATH6KL_DBG_IRQ,
 122                            "Host Int status:           0x%x\n",
 123                            irq_proc_reg->host_int_status);
 124                 ath6kl_dbg(ATH6KL_DBG_IRQ,
 125                            "CPU Int status:            0x%x\n",
 126                            irq_proc_reg->cpu_int_status);
 127                 ath6kl_dbg(ATH6KL_DBG_IRQ,
 128                            "Error Int status:          0x%x\n",
 129                            irq_proc_reg->error_int_status);
 130                 ath6kl_dbg(ATH6KL_DBG_IRQ,
 131                            "Counter Int status:        0x%x\n",
 132                            irq_proc_reg->counter_int_status);
 133                 ath6kl_dbg(ATH6KL_DBG_IRQ,
 134                            "Mbox Frame:                0x%x\n",
 135                            irq_proc_reg->mbox_frame);
 136                 ath6kl_dbg(ATH6KL_DBG_IRQ,
 137                            "Rx Lookahead Valid:        0x%x\n",
 138                            irq_proc_reg->rx_lkahd_valid);
 139                 ath6kl_dbg(ATH6KL_DBG_IRQ,
 140                            "Rx Lookahead 0:            0x%x\n",
 141                            irq_proc_reg->rx_lkahd[0]);
 142                 ath6kl_dbg(ATH6KL_DBG_IRQ,
 143                            "Rx Lookahead 1:            0x%x\n",
 144                            irq_proc_reg->rx_lkahd[1]);
 145
 146                 if (dev->ar->mbox_info.gmbox_addr != 0) {
 147                         /*
 148                          * If the target supports GMBOX hardware, dump some
 149                          * additional state.
 150                          */
 151                         ath6kl_dbg(ATH6KL_DBG_IRQ,
 152                                    "GMBOX Host Int status 2:   0x%x\n",
 153                                    irq_proc_reg->host_int_status2);
 154                         ath6kl_dbg(ATH6KL_DBG_IRQ,
 155                                    "GMBOX RX Avail:            0x%x\n",
 156                                    irq_proc_reg->gmbox_rx_avail);
 157                         ath6kl_dbg(ATH6KL_DBG_IRQ,
 158                                    "GMBOX lookahead alias 0:   0x%x\n",
 159                                    irq_proc_reg->rx_gmbox_lkahd_alias[0]);
 160                         ath6kl_dbg(ATH6KL_DBG_IRQ,
 161                                    "GMBOX lookahead alias 1:   0x%x\n",
 162                                    irq_proc_reg->rx_gmbox_lkahd_alias[1]);
 163                 }
 164
 165         }
 166
 167         if (irq_enable_reg != NULL) {
 168                 ath6kl_dbg(ATH6KL_DBG_IRQ,
 169                            "Int status Enable:         0x%x\n",
 170                            irq_enable_reg->int_status_en);
 171                 ath6kl_dbg(ATH6KL_DBG_IRQ, "Counter Int status Enable: 0x%x\n",
 172                            irq_enable_reg->cntr_int_status_en);
 173         }
 174         ath6kl_dbg(ATH6KL_DBG_IRQ, "<------------------------------->\n");
 175 }
 176
 177 static void dump_cred_dist(struct htc_endpoint_credit_dist *ep_dist)
 178 {
 179         ath6kl_dbg(ATH6KL_DBG_CREDIT,
 180                    "--- endpoint: %d  svc_id: 0x%X ---\n",
 181                    ep_dist->endpoint, ep_dist->svc_id);
 182         ath6kl_dbg(ATH6KL_DBG_CREDIT, " dist_flags     : 0x%X\n",
 183                    ep_dist->dist_flags);
 184         ath6kl_dbg(ATH6KL_DBG_CREDIT, " cred_norm      : %d\n",
 185                    ep_dist->cred_norm);
 186         ath6kl_dbg(ATH6KL_DBG_CREDIT, " cred_min       : %d\n",
 187                    ep_dist->cred_min);
 188         ath6kl_dbg(ATH6KL_DBG_CREDIT, " credits        : %d\n",
 189                    ep_dist->credits);
 190         ath6kl_dbg(ATH6KL_DBG_CREDIT, " cred_assngd    : %d\n",
 191                    ep_dist->cred_assngd);
 192         ath6kl_dbg(ATH6KL_DBG_CREDIT, " seek_cred      : %d\n",
 193                    ep_dist->seek_cred);
 194         ath6kl_dbg(ATH6KL_DBG_CREDIT, " cred_sz        : %d\n",
 195                    ep_dist->cred_sz);
 196         ath6kl_dbg(ATH6KL_DBG_CREDIT, " cred_per_msg   : %d\n",
 197                    ep_dist->cred_per_msg);
 198         ath6kl_dbg(ATH6KL_DBG_CREDIT, " cred_to_dist   : %d\n",
 199                    ep_dist->cred_to_dist);
 200         ath6kl_dbg(ATH6KL_DBG_CREDIT, " txq_depth      : %d\n",
 201                    get_queue_depth(&ep_dist->htc_ep->txq));
 202         ath6kl_dbg(ATH6KL_DBG_CREDIT,
 203                    "----------------------------------\n");
 204 }
 205
 206 /* FIXME: move to htc.c */
 207 void dump_cred_dist_stats(struct htc_target *target)
 208 {
 209         struct htc_endpoint_credit_dist *ep_list;
 210
 211         list_for_each_entry(ep_list, &target->cred_dist_list, list)
 212                 dump_cred_dist(ep_list);
 213
 214         ath6kl_dbg(ATH6KL_DBG_CREDIT,
 215                    "credit distribution total %d free %d\n",
 216                    target->credit_info->total_avail_credits,
 217                    target->credit_info->cur_free_credits);
 218 }
 219
 220 static int ath6kl_debugfs_open(struct inode *inode, struct file *file)
 221 {
 222         file->private_data = inode->i_private;
 223         return 0;
 224 }
 225
 226 void ath6kl_debug_war(struct ath6kl *ar, enum ath6kl_war war)
 227 {
 228         switch (war) {
 229         case ATH6KL_WAR_INVALID_RATE:
 230                 ar->debug.war_stats.invalid_rate++;
 231                 break;
 232         }
 233 }
 234
 235 static ssize_t read_file_war_stats(struct file *file, char __user *user_buf,
 236                                    size_t count, loff_t *ppos)
 237 {
 238         struct ath6kl *ar = file->private_data;
 239         char *buf;
 240         unsigned int len = 0, buf_len = 1500;
 241         ssize_t ret_cnt;
 242
 243         buf = kzalloc(buf_len, GFP_KERNEL);
 244         if (!buf)
 245                 return -ENOMEM;
 246
 247         len += scnprintf(buf + len, buf_len - len, "\n");
 248         len += scnprintf(buf + len, buf_len - len, "%25s\n",
 249                          "Workaround stats");
 250         len += scnprintf(buf + len, buf_len - len, "%25s\n\n",
 251                          "=================");
 252         len += scnprintf(buf + len, buf_len - len, "%20s %10u\n",
 253                          "Invalid rates", ar->debug.war_stats.invalid_rate);
 254
 255         if (WARN_ON(len > buf_len))
 256                 len = buf_len;
 257
 258         ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 259
 260         kfree(buf);
 261         return ret_cnt;
 262 }
 263
 264 static const struct file_operations fops_war_stats = {
 265         .read = read_file_war_stats,
 266         .open = ath6kl_debugfs_open,
 267         .owner = THIS_MODULE,
 268         .llseek = default_llseek,
 269 };
 270
 271 void ath6kl_debug_fwlog_event(struct ath6kl *ar, const void *buf, size_t len)
 272 {
 273         struct ath6kl_fwlog_slot *slot;
 274         struct sk_buff *skb;
 275         size_t slot_len;
 276
 277         if (WARN_ON(len > ATH6KL_FWLOG_PAYLOAD_SIZE))
 278                 return;
 279
 280         slot_len = sizeof(*slot) + ATH6KL_FWLOG_PAYLOAD_SIZE;
 281
 282         skb = alloc_skb(slot_len, GFP_KERNEL);
 283         if (!skb)
 284                 return;
 285
 286         slot = (struct ath6kl_fwlog_slot *) skb_put(skb, slot_len);
 287         slot->timestamp = cpu_to_le32(jiffies);
 288         slot->length = cpu_to_le32(len);
 289         memcpy(slot->payload, buf, len);
 290
 291         /* Need to pad each record to fixed length ATH6KL_FWLOG_PAYLOAD_SIZE */
 292         memset(slot->payload + len, 0, ATH6KL_FWLOG_PAYLOAD_SIZE - len);
 293
 294         spin_lock(&ar->debug.fwlog_queue.lock);
 295
 296         __skb_queue_tail(&ar->debug.fwlog_queue, skb);
 297         complete(&ar->debug.fwlog_completion);
 298
 299         /* drop oldest entries */
 300         while (skb_queue_len(&ar->debug.fwlog_queue) >
 301                ATH6KL_FWLOG_MAX_ENTRIES) {
 302                 skb = __skb_dequeue(&ar->debug.fwlog_queue);
 303                 kfree_skb(skb);
 304         }
 305
 306         spin_unlock(&ar->debug.fwlog_queue.lock);
 307
 308         return;
 309 }
 310
 311 static int ath6kl_fwlog_open(struct inode *inode, struct file *file)
 312 {
 313         struct ath6kl *ar = inode->i_private;
 314
 315         if (ar->debug.fwlog_open)
 316                 return -EBUSY;
 317
 318         ar->debug.fwlog_open = true;
 319
 320         file->private_data = inode->i_private;
 321         return 0;
 322 }
 323
 324 static int ath6kl_fwlog_release(struct inode *inode, struct file *file)
 325 {
 326         struct ath6kl *ar = inode->i_private;
 327
 328         ar->debug.fwlog_open = false;
 329
 330         return 0;
 331 }
 332
 333 static ssize_t ath6kl_fwlog_read(struct file *file, char __user *user_buf,
 334                                  size_t count, loff_t *ppos)
 335 {
 336         struct ath6kl *ar = file->private_data;
 337         struct sk_buff *skb;
 338         ssize_t ret_cnt;
 339         size_t len = 0;
 340         char *buf;
 341
 342         buf = vmalloc(count);
 343         if (!buf)
 344                 return -ENOMEM;
 345
 346         /* read undelivered logs from firmware */
 347         ath6kl_read_fwlogs(ar);
 348
 349         spin_lock(&ar->debug.fwlog_queue.lock);
 350
 351         while ((skb = __skb_dequeue(&ar->debug.fwlog_queue))) {
 352                 if (skb->len > count - len) {
 353                         /* not enough space, put skb back and leave */
 354                         __skb_queue_head(&ar->debug.fwlog_queue, skb);
 355                         break;
 356                 }
 357
 358
 359                 memcpy(buf + len, skb->data, skb->len);
 360                 len += skb->len;
 361
 362                 kfree_skb(skb);
 363         }
 364
 365         spin_unlock(&ar->debug.fwlog_queue.lock);
 366
 367         /* FIXME: what to do if len == 0? */
 368
 369         ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 370
 371         vfree(buf);
 372
 373         return ret_cnt;
 374 }
 375
 376 static const struct file_operations fops_fwlog = {
 377         .open = ath6kl_fwlog_open,
 378         .release = ath6kl_fwlog_release,
 379         .read = ath6kl_fwlog_read,
 380         .owner = THIS_MODULE,
 381         .llseek = default_llseek,
 382 };
 383
 384 static ssize_t ath6kl_fwlog_block_read(struct file *file,
 385                                        char __user *user_buf,
 386                                        size_t count,
 387                                        loff_t *ppos)
 388 {
 389         struct ath6kl *ar = file->private_data;
 390         struct sk_buff *skb;
 391         ssize_t ret_cnt;
 392         size_t len = 0, not_copied;
 393         char *buf;
 394         int ret;
 395
 396         buf = vmalloc(count);
 397         if (!buf)
 398                 return -ENOMEM;
 399
 400         spin_lock(&ar->debug.fwlog_queue.lock);
 401
 402         if (skb_queue_len(&ar->debug.fwlog_queue) == 0) {
 403                 /* we must init under queue lock */
 404                 init_completion(&ar->debug.fwlog_completion);
 405
 406                 spin_unlock(&ar->debug.fwlog_queue.lock);
 407
 408                 ret = wait_for_completion_interruptible(
 409                         &ar->debug.fwlog_completion);
 410                 if (ret == -ERESTARTSYS)
 411                         return ret;
 412
 413                 spin_lock(&ar->debug.fwlog_queue.lock);
 414         }
 415
 416         while ((skb = __skb_dequeue(&ar->debug.fwlog_queue))) {
 417                 if (skb->len > count - len) {
 418                         /* not enough space, put skb back and leave */
 419                         __skb_queue_head(&ar->debug.fwlog_queue, skb);
 420                         break;
 421                 }
 422
 423
 424                 memcpy(buf + len, skb->data, skb->len);
 425                 len += skb->len;
 426
 427                 kfree_skb(skb);
 428         }
 429
 430         spin_unlock(&ar->debug.fwlog_queue.lock);
 431
 432         /* FIXME: what to do if len == 0? */
 433
 434         not_copied = copy_to_user(user_buf, buf, len);
 435         if (not_copied != 0) {
 436                 ret_cnt = -EFAULT;
 437                 goto out;
 438         }
 439
 440         *ppos = *ppos + len;
 441
 442         ret_cnt = len;
 443
 444 out:
 445         vfree(buf);
 446
 447         return ret_cnt;
 448 }
 449
 450 static const struct file_operations fops_fwlog_block = {
 451         .open = ath6kl_fwlog_open,
 452         .release = ath6kl_fwlog_release,
 453         .read = ath6kl_fwlog_block_read,
 454         .owner = THIS_MODULE,
 455         .llseek = default_llseek,
 456 };
 457
 458 static ssize_t ath6kl_fwlog_mask_read(struct file *file, char __user *user_buf,
 459                                       size_t count, loff_t *ppos)
 460 {
 461         struct ath6kl *ar = file->private_data;
 462         char buf[16];
 463         int len;
 464
 465         len = snprintf(buf, sizeof(buf), "0x%x\n", ar->debug.fwlog_mask);
 466
 467         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 468 }
 469
 470 static ssize_t ath6kl_fwlog_mask_write(struct file *file,
 471                                        const char __user *user_buf,
 472                                        size_t count, loff_t *ppos)
 473 {
 474         struct ath6kl *ar = file->private_data;
 475         int ret;
 476
 477         ret = kstrtou32_from_user(user_buf, count, 0, &ar->debug.fwlog_mask);
 478         if (ret)
 479                 return ret;
 480
 481         ret = ath6kl_wmi_config_debug_module_cmd(ar->wmi,
 482                                                  ATH6KL_FWLOG_VALID_MASK,
 483                                                  ar->debug.fwlog_mask);
 484         if (ret)
 485                 return ret;
 486
 487         return count;
 488 }
 489
 490 static const struct file_operations fops_fwlog_mask = {
 491         .open = ath6kl_debugfs_open,
 492         .read = ath6kl_fwlog_mask_read,
 493         .write = ath6kl_fwlog_mask_write,
 494         .owner = THIS_MODULE,
 495         .llseek = default_llseek,
 496 };
 497
 498 static ssize_t read_file_tgt_stats(struct file *file, char __user *user_buf,
 499                                    size_t count, loff_t *ppos)
 500 {
 501         struct ath6kl *ar = file->private_data;
 502         struct ath6kl_vif *vif;
 503         struct target_stats *tgt_stats;
 504         char *buf;
 505         unsigned int len = 0, buf_len = 1500;
 506         int i;
 507         long left;
 508         ssize_t ret_cnt;
 509
 510         vif = ath6kl_vif_first(ar);
 511         if (!vif)
 512                 return -EIO;
 513
 514         tgt_stats = &vif->target_stats;
 515
 516         buf = kzalloc(buf_len, GFP_KERNEL);
 517         if (!buf)
 518                 return -ENOMEM;
 519
 520         if (down_interruptible(&ar->sem)) {
 521                 kfree(buf);
 522                 return -EBUSY;
 523         }
 524
 525         set_bit(STATS_UPDATE_PEND, &vif->flags);
 526
 527         if (ath6kl_wmi_get_stats_cmd(ar->wmi, 0)) {
 528                 up(&ar->sem);
 529                 kfree(buf);
 530                 return -EIO;
 531         }
 532
 533         left = wait_event_interruptible_timeout(ar->event_wq,
 534                                                 !test_bit(STATS_UPDATE_PEND,
 535                                                 &vif->flags), WMI_TIMEOUT);
 536
 537         up(&ar->sem);
 538
 539         if (left <= 0) {
 540                 kfree(buf);
 541                 return -ETIMEDOUT;
 542         }
 543
 544         len += scnprintf(buf + len, buf_len - len, "\n");
 545         len += scnprintf(buf + len, buf_len - len, "%25s\n",
 546                          "Target Tx stats");
 547         len += scnprintf(buf + len, buf_len - len, "%25s\n\n",
 548                          "=================");
 549         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 550                          "Ucast packets", tgt_stats->tx_ucast_pkt);
 551         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 552                          "Bcast packets", tgt_stats->tx_bcast_pkt);
 553         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 554                          "Ucast byte", tgt_stats->tx_ucast_byte);
 555         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 556                          "Bcast byte", tgt_stats->tx_bcast_byte);
 557         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 558                          "Rts success cnt", tgt_stats->tx_rts_success_cnt);
 559         for (i = 0; i < 4; i++)
 560                 len += scnprintf(buf + len, buf_len - len,
 561                                  "%18s %d %10llu\n", "PER on ac",
 562                                  i, tgt_stats->tx_pkt_per_ac[i]);
 563         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 564                          "Error", tgt_stats->tx_err);
 565         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 566                          "Fail count", tgt_stats->tx_fail_cnt);
 567         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 568                          "Retry count", tgt_stats->tx_retry_cnt);
 569         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 570                          "Multi retry cnt", tgt_stats->tx_mult_retry_cnt);
 571         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 572                          "Rts fail cnt", tgt_stats->tx_rts_fail_cnt);
 573         len += scnprintf(buf + len, buf_len - len, "%25s %10llu\n\n",
 574                          "TKIP counter measure used",
 575                          tgt_stats->tkip_cnter_measures_invoked);
 576
 577         len += scnprintf(buf + len, buf_len - len, "%25s\n",
 578                          "Target Rx stats");
 579         len += scnprintf(buf + len, buf_len - len, "%25s\n",
 580                          "=================");
 581
 582         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 583                          "Ucast packets", tgt_stats->rx_ucast_pkt);
 584         len += scnprintf(buf + len, buf_len - len, "%20s %10d\n",
 585                          "Ucast Rate", tgt_stats->rx_ucast_rate);
 586         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 587                          "Bcast packets", tgt_stats->rx_bcast_pkt);
 588         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 589                          "Ucast byte", tgt_stats->rx_ucast_byte);
 590         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 591                          "Bcast byte", tgt_stats->rx_bcast_byte);
 592         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 593                          "Fragmented pkt", tgt_stats->rx_frgment_pkt);
 594         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 595                          "Error", tgt_stats->rx_err);
 596         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 597                          "CRC Err", tgt_stats->rx_crc_err);
 598         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 599                          "Key chache miss", tgt_stats->rx_key_cache_miss);
 600         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 601                          "Decrypt Err", tgt_stats->rx_decrypt_err);
 602         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 603                          "Duplicate frame", tgt_stats->rx_dupl_frame);
 604         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 605                          "Tkip Mic failure", tgt_stats->tkip_local_mic_fail);
 606         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 607                          "TKIP format err", tgt_stats->tkip_fmt_err);
 608         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 609                          "CCMP format Err", tgt_stats->ccmp_fmt_err);
 610         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n\n",
 611                          "CCMP Replay Err", tgt_stats->ccmp_replays);
 612
 613         len += scnprintf(buf + len, buf_len - len, "%25s\n",
 614                          "Misc Target stats");
 615         len += scnprintf(buf + len, buf_len - len, "%25s\n",
 616                          "=================");
 617         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 618                          "Beacon Miss count", tgt_stats->cs_bmiss_cnt);
 619         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 620                          "Num Connects", tgt_stats->cs_connect_cnt);
 621         len += scnprintf(buf + len, buf_len - len, "%20s %10llu\n",
 622                          "Num disconnects", tgt_stats->cs_discon_cnt);
 623         len += scnprintf(buf + len, buf_len - len, "%20s %10d\n",
 624                          "Beacon avg rssi", tgt_stats->cs_ave_beacon_rssi);
 625
 626         if (len > buf_len)
 627                 len = buf_len;
 628
 629         ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 630
 631         kfree(buf);
 632         return ret_cnt;
 633 }
 634
 635 static const struct file_operations fops_tgt_stats = {
 636         .read = read_file_tgt_stats,
 637         .open = ath6kl_debugfs_open,
 638         .owner = THIS_MODULE,
 639         .llseek = default_llseek,
 640 };
 641
 642 #define print_credit_info(fmt_str, ep_list_field)               \
 643         (len += scnprintf(buf + len, buf_len - len, fmt_str,    \
 644                          ep_list->ep_list_field))
 645 #define CREDIT_INFO_DISPLAY_STRING_LEN  200
 646 #define CREDIT_INFO_LEN 128
 647
 648 static ssize_t read_file_credit_dist_stats(struct file *file,
 649                                            char __user *user_buf,
 650                                            size_t count, loff_t *ppos)
 651 {
 652         struct ath6kl *ar = file->private_data;
 653         struct htc_target *target = ar->htc_target;
 654         struct htc_endpoint_credit_dist *ep_list;
 655         char *buf;
 656         unsigned int buf_len, len = 0;
 657         ssize_t ret_cnt;
 658
 659         buf_len = CREDIT_INFO_DISPLAY_STRING_LEN +
 660                   get_queue_depth(&target->cred_dist_list) * CREDIT_INFO_LEN;
 661         buf = kzalloc(buf_len, GFP_KERNEL);
 662         if (!buf)
 663                 return -ENOMEM;
 664
 665         len += scnprintf(buf + len, buf_len - len, "%25s%5d\n",
 666                          "Total Avail Credits: ",
 667                          target->credit_info->total_avail_credits);
 668         len += scnprintf(buf + len, buf_len - len, "%25s%5d\n",
 669                          "Free credits :",
 670                          target->credit_info->cur_free_credits);
 671
 672         len += scnprintf(buf + len, buf_len - len,
 673                          " Epid  Flags    Cred_norm  Cred_min  Credits  Cred_assngd"
 674                          "  Seek_cred  Cred_sz  Cred_per_msg  Cred_to_dist"
 675                          "  qdepth\n");
 676
 677         list_for_each_entry(ep_list, &target->cred_dist_list, list) {
 678                 print_credit_info("  %2d", endpoint);
 679                 print_credit_info("%10x", dist_flags);
 680                 print_credit_info("%8d", cred_norm);
 681                 print_credit_info("%9d", cred_min);
 682                 print_credit_info("%9d", credits);
 683                 print_credit_info("%10d", cred_assngd);
 684                 print_credit_info("%13d", seek_cred);
 685                 print_credit_info("%12d", cred_sz);
 686                 print_credit_info("%9d", cred_per_msg);
 687                 print_credit_info("%14d", cred_to_dist);
 688                 len += scnprintf(buf + len, buf_len - len, "%12d\n",
 689                                  get_queue_depth(&ep_list->htc_ep->txq));
 690         }
 691
 692         if (len > buf_len)
 693                 len = buf_len;
 694
 695         ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 696         kfree(buf);
 697         return ret_cnt;
 698 }
 699
 700 static const struct file_operations fops_credit_dist_stats = {
 701         .read = read_file_credit_dist_stats,
 702         .open = ath6kl_debugfs_open,
 703         .owner = THIS_MODULE,
 704         .llseek = default_llseek,
 705 };
 706
 707 static unsigned int print_endpoint_stat(struct htc_target *target, char *buf,
 708                                         unsigned int buf_len, unsigned int len,
 709                                         int offset, const char *name)
 710 {
 711         int i;
 712         struct htc_endpoint_stats *ep_st;
 713         u32 *counter;
 714
 715         len += scnprintf(buf + len, buf_len - len, "%s:", name);
 716         for (i = 0; i < ENDPOINT_MAX; i++) {
 717                 ep_st = &target->endpoint[i].ep_st;
 718                 counter = ((u32 *) ep_st) + (offset / 4);
 719                 len += scnprintf(buf + len, buf_len - len, " %u", *counter);
 720         }
 721         len += scnprintf(buf + len, buf_len - len, "\n");
 722
 723         return len;
 724 }
 725
 726 static ssize_t ath6kl_endpoint_stats_read(struct file *file,
 727                                           char __user *user_buf,
 728                                           size_t count, loff_t *ppos)
 729 {
 730         struct ath6kl *ar = file->private_data;
 731         struct htc_target *target = ar->htc_target;
 732         char *buf;
 733         unsigned int buf_len, len = 0;
 734         ssize_t ret_cnt;
 735
 736         buf_len = sizeof(struct htc_endpoint_stats) / sizeof(u32) *
 737                 (25 + ENDPOINT_MAX * 11);
 738         buf = kmalloc(buf_len, GFP_KERNEL);
 739         if (!buf)
 740                 return -ENOMEM;
 741
 742 #define EPSTAT(name)                                                    \
 743         do {                                                            \
 744                 len = print_endpoint_stat(target, buf, buf_len, len,    \
 745                                           offsetof(struct htc_endpoint_stats, \
 746                                                    name),               \
 747                                           #name);                       \
 748         } while (0)
 749
 750         EPSTAT(cred_low_indicate);
 751         EPSTAT(tx_issued);
 752         EPSTAT(tx_pkt_bundled);
 753         EPSTAT(tx_bundles);
 754         EPSTAT(tx_dropped);
 755         EPSTAT(tx_cred_rpt);
 756         EPSTAT(cred_rpt_from_rx);
 757         EPSTAT(cred_rpt_from_other);
 758         EPSTAT(cred_rpt_ep0);
 759         EPSTAT(cred_from_rx);
 760         EPSTAT(cred_from_other);
 761         EPSTAT(cred_from_ep0);
 762         EPSTAT(cred_cosumd);
 763         EPSTAT(cred_retnd);
 764         EPSTAT(rx_pkts);
 765         EPSTAT(rx_lkahds);
 766         EPSTAT(rx_bundl);
 767         EPSTAT(rx_bundle_lkahd);
 768         EPSTAT(rx_bundle_from_hdr);
 769         EPSTAT(rx_alloc_thresh_hit);
 770         EPSTAT(rxalloc_thresh_byte);
 771 #undef EPSTAT
 772
 773         if (len > buf_len)
 774                 len = buf_len;
 775
 776         ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
 777         kfree(buf);
 778         return ret_cnt;
 779 }
 780
 781 static ssize_t ath6kl_endpoint_stats_write(struct file *file,
 782                                            const char __user *user_buf,
 783                                            size_t count, loff_t *ppos)
 784 {
 785         struct ath6kl *ar = file->private_data;
 786         struct htc_target *target = ar->htc_target;
 787         int ret, i;
 788         u32 val;
 789         struct htc_endpoint_stats *ep_st;
 790
 791         ret = kstrtou32_from_user(user_buf, count, 0, &val);
 792         if (ret)
 793                 return ret;
 794         if (val == 0) {
 795                 for (i = 0; i < ENDPOINT_MAX; i++) {
 796                         ep_st = &target->endpoint[i].ep_st;
 797                         memset(ep_st, 0, sizeof(*ep_st));
 798                 }
 799         }
 800
 801         return count;
 802 }
 803
 804 static const struct file_operations fops_endpoint_stats = {
 805         .open = ath6kl_debugfs_open,
 806         .read = ath6kl_endpoint_stats_read,
 807         .write = ath6kl_endpoint_stats_write,
 808         .owner = THIS_MODULE,
 809         .llseek = default_llseek,
 810 };
 811
 812 static unsigned long ath6kl_get_num_reg(void)
 813 {
 814         int i;
 815         unsigned long n_reg = 0;
 816
 817         for (i = 0; i < ARRAY_SIZE(diag_reg); i++)
 818                 n_reg = n_reg +
 819                      (diag_reg[i].reg_end - diag_reg[i].reg_start) / 4 + 1;
 820
 821         return n_reg;
 822 }
 823
 824 static bool ath6kl_dbg_is_diag_reg_valid(u32 reg_addr)
 825 {
 826         int i;
 827
 828         for (i = 0; i < ARRAY_SIZE(diag_reg); i++) {
 829                 if (reg_addr >= diag_reg[i].reg_start &&
 830                     reg_addr <= diag_reg[i].reg_end)
 831                         return true;
 832         }
 833
 834         return false;
 835 }
 836
 837 static ssize_t ath6kl_regread_read(struct file *file, char __user *user_buf,
 838                                     size_t count, loff_t *ppos)
 839 {
 840         struct ath6kl *ar = file->private_data;
 841         u8 buf[50];
 842         unsigned int len = 0;
 843
 844         if (ar->debug.dbgfs_diag_reg)
 845                 len += scnprintf(buf + len, sizeof(buf) - len, "0x%x\n",
 846                                 ar->debug.dbgfs_diag_reg);
 847         else
 848                 len += scnprintf(buf + len, sizeof(buf) - len,
 849                                  "All diag registers\n");
 850
 851         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 852 }
 853
 854 static ssize_t ath6kl_regread_write(struct file *file,
 855                                     const char __user *user_buf,
 856                                     size_t count, loff_t *ppos)
 857 {
 858         struct ath6kl *ar = file->private_data;
 859         unsigned long reg_addr;
 860
 861         if (kstrtoul_from_user(user_buf, count, 0, &reg_addr))
 862                 return -EINVAL;
 863
 864         if ((reg_addr % 4) != 0)
 865                 return -EINVAL;
 866
 867         if (reg_addr && !ath6kl_dbg_is_diag_reg_valid(reg_addr))
 868                 return -EINVAL;
 869
 870         ar->debug.dbgfs_diag_reg = reg_addr;
 871
 872         return count;
 873 }
 874
 875 static const struct file_operations fops_diag_reg_read = {
 876         .read = ath6kl_regread_read,
 877         .write = ath6kl_regread_write,
 878         .open = ath6kl_debugfs_open,
 879         .owner = THIS_MODULE,
 880         .llseek = default_llseek,
 881 };
 882
 883 static int ath6kl_regdump_open(struct inode *inode, struct file *file)
 884 {
 885         struct ath6kl *ar = inode->i_private;
 886         u8 *buf;
 887         unsigned long int reg_len;
 888         unsigned int len = 0, n_reg;
 889         u32 addr;
 890         __le32 reg_val;
 891         int i, status;
 892
 893         /* Dump all the registers if no register is specified */
 894         if (!ar->debug.dbgfs_diag_reg)
 895                 n_reg = ath6kl_get_num_reg();
 896         else
 897                 n_reg = 1;
 898
 899         reg_len = n_reg * REG_OUTPUT_LEN_PER_LINE;
 900         if (n_reg > 1)
 901                 reg_len += REGTYPE_STR_LEN;
 902
 903         buf = vmalloc(reg_len);
 904         if (!buf)
 905                 return -ENOMEM;
 906
 907         if (n_reg == 1) {
 908                 addr = ar->debug.dbgfs_diag_reg;
 909
 910                 status = ath6kl_diag_read32(ar,
 911                                 TARG_VTOP(ar->target_type, addr),
 912                                 (u32 *)&reg_val);
 913                 if (status)
 914                         goto fail_reg_read;
 915
 916                 len += scnprintf(buf + len, reg_len - len,
 917                                  "0x%06x 0x%08x\n", addr, le32_to_cpu(reg_val));
 918                 goto done;
 919         }
 920
 921         for (i = 0; i < ARRAY_SIZE(diag_reg); i++) {
 922                 len += scnprintf(buf + len, reg_len - len,
 923                                 "%s\n", diag_reg[i].reg_info);
 924                 for (addr = diag_reg[i].reg_start;
 925                      addr <= diag_reg[i].reg_end; addr += 4) {
 926                         status = ath6kl_diag_read32(ar,
 927                                         TARG_VTOP(ar->target_type, addr),
 928                                         (u32 *)&reg_val);
 929                         if (status)
 930                                 goto fail_reg_read;
 931
 932                         len += scnprintf(buf + len, reg_len - len,
 933                                         "0x%06x 0x%08x\n",
 934                                         addr, le32_to_cpu(reg_val));
 935                 }
 936         }
 937
 938 done:
 939         file->private_data = buf;
 940         return 0;
 941
 942 fail_reg_read:
 943         ath6kl_warn("Unable to read memory:%u\n", addr);
 944         vfree(buf);
 945         return -EIO;
 946 }
 947
 948 static ssize_t ath6kl_regdump_read(struct file *file, char __user *user_buf,
 949                                   size_t count, loff_t *ppos)
 950 {
 951         u8 *buf = file->private_data;
 952         return simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
 953 }
 954
 955 static int ath6kl_regdump_release(struct inode *inode, struct file *file)
 956 {
 957         vfree(file->private_data);
 958         return 0;
 959 }
 960
 961 static const struct file_operations fops_reg_dump = {
 962         .open = ath6kl_regdump_open,
 963         .read = ath6kl_regdump_read,
 964         .release = ath6kl_regdump_release,
 965         .owner = THIS_MODULE,
 966         .llseek = default_llseek,
 967 };
 968
 969 static ssize_t ath6kl_lrssi_roam_write(struct file *file,
 970                                        const char __user *user_buf,
 971                                        size_t count, loff_t *ppos)
 972 {
 973         struct ath6kl *ar = file->private_data;
 974         unsigned long lrssi_roam_threshold;
 975
 976         if (kstrtoul_from_user(user_buf, count, 0, &lrssi_roam_threshold))
 977                 return -EINVAL;
 978
 979         ar->lrssi_roam_threshold = lrssi_roam_threshold;
 980
 981         ath6kl_wmi_set_roam_lrssi_cmd(ar->wmi, ar->lrssi_roam_threshold);
 982
 983         return count;
 984 }
 985
 986 static ssize_t ath6kl_lrssi_roam_read(struct file *file,
 987                                       char __user *user_buf,
 988                                       size_t count, loff_t *ppos)
 989 {
 990         struct ath6kl *ar = file->private_data;
 991         char buf[32];
 992         unsigned int len;
 993
 994         len = snprintf(buf, sizeof(buf), "%u\n", ar->lrssi_roam_threshold);
 995
 996         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
 997 }
 998
 999 static const struct file_operations fops_lrssi_roam_threshold = {
1000         .read = ath6kl_lrssi_roam_read,
1001         .write = ath6kl_lrssi_roam_write,
1002         .open = ath6kl_debugfs_open,
1003         .owner = THIS_MODULE,
1004         .llseek = default_llseek,
1005 };
1006
1007 static ssize_t ath6kl_regwrite_read(struct file *file,
1008                                     char __user *user_buf,
1009                                     size_t count, loff_t *ppos)
1010 {
1011         struct ath6kl *ar = file->private_data;
1012         u8 buf[32];
1013         unsigned int len = 0;
1014
1015         len = scnprintf(buf, sizeof(buf), "Addr: 0x%x Val: 0x%x\n",
1016                         ar->debug.diag_reg_addr_wr, ar->debug.diag_reg_val_wr);
1017
1018         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1019 }
1020
1021 static ssize_t ath6kl_regwrite_write(struct file *file,
1022                                      const char __user *user_buf,
1023                                      size_t count, loff_t *ppos)
1024 {
1025         struct ath6kl *ar = file->private_data;
1026         char buf[32];
1027         char *sptr, *token;
1028         unsigned int len = 0;
1029         u32 reg_addr, reg_val;
1030
1031         len = min(count, sizeof(buf) - 1);
1032         if (copy_from_user(buf, user_buf, len))
1033                 return -EFAULT;
1034
1035         buf[len] = '\0';
1036         sptr = buf;
1037
1038         token = strsep(&sptr, "=");
1039         if (!token)
1040                 return -EINVAL;
1041
1042         if (kstrtou32(token, 0, &reg_addr))
1043                 return -EINVAL;
1044
1045         if (!ath6kl_dbg_is_diag_reg_valid(reg_addr))
1046                 return -EINVAL;
1047
1048         if (kstrtou32(sptr, 0, &reg_val))
1049                 return -EINVAL;
1050
1051         ar->debug.diag_reg_addr_wr = reg_addr;
1052         ar->debug.diag_reg_val_wr = reg_val;
1053
1054         if (ath6kl_diag_write32(ar, ar->debug.diag_reg_addr_wr,
1055                                 cpu_to_le32(ar->debug.diag_reg_val_wr)))
1056                 return -EIO;
1057
1058         return count;
1059 }
1060
1061 static const struct file_operations fops_diag_reg_write = {
1062         .read = ath6kl_regwrite_read,
1063         .write = ath6kl_regwrite_write,
1064         .open = ath6kl_debugfs_open,
1065         .owner = THIS_MODULE,
1066         .llseek = default_llseek,
1067 };
1068
1069 int ath6kl_debug_roam_tbl_event(struct ath6kl *ar, const void *buf,
1070                                 size_t len)
1071 {
1072         const struct wmi_target_roam_tbl *tbl;
1073         u16 num_entries;
1074
1075         if (len < sizeof(*tbl))
1076                 return -EINVAL;
1077
1078         tbl = (const struct wmi_target_roam_tbl *) buf;
1079         num_entries = le16_to_cpu(tbl->num_entries);
1080         if (sizeof(*tbl) + num_entries * sizeof(struct wmi_bss_roam_info) >
1081             len)
1082                 return -EINVAL;
1083
1084         if (ar->debug.roam_tbl == NULL ||
1085             ar->debug.roam_tbl_len < (unsigned int) len) {
1086                 kfree(ar->debug.roam_tbl);
1087                 ar->debug.roam_tbl = kmalloc(len, GFP_ATOMIC);
1088                 if (ar->debug.roam_tbl == NULL)
1089                         return -ENOMEM;
1090         }
1091
1092         memcpy(ar->debug.roam_tbl, buf, len);
1093         ar->debug.roam_tbl_len = len;
1094
1095         if (test_bit(ROAM_TBL_PEND, &ar->flag)) {
1096                 clear_bit(ROAM_TBL_PEND, &ar->flag);
1097                 wake_up(&ar->event_wq);
1098         }
1099
1100         return 0;
1101 }
1102
1103 static ssize_t ath6kl_roam_table_read(struct file *file, char __user *user_buf,
1104                                       size_t count, loff_t *ppos)
1105 {
1106         struct ath6kl *ar = file->private_data;
1107         int ret;
1108         long left;
1109         struct wmi_target_roam_tbl *tbl;
1110         u16 num_entries, i;
1111         char *buf;
1112         unsigned int len, buf_len;
1113         ssize_t ret_cnt;
1114
1115         if (down_interruptible(&ar->sem))
1116                 return -EBUSY;
1117
1118         set_bit(ROAM_TBL_PEND, &ar->flag);
1119
1120         ret = ath6kl_wmi_get_roam_tbl_cmd(ar->wmi);
1121         if (ret) {
1122                 up(&ar->sem);
1123                 return ret;
1124         }
1125
1126         left = wait_event_interruptible_timeout(
1127                 ar->event_wq, !test_bit(ROAM_TBL_PEND, &ar->flag), WMI_TIMEOUT);
1128         up(&ar->sem);
1129
1130         if (left <= 0)
1131                 return -ETIMEDOUT;
1132
1133         if (ar->debug.roam_tbl == NULL)
1134                 return -ENOMEM;
1135
1136         tbl = (struct wmi_target_roam_tbl *) ar->debug.roam_tbl;
1137         num_entries = le16_to_cpu(tbl->num_entries);
1138
1139         buf_len = 100 + num_entries * 100;
1140         buf = kzalloc(buf_len, GFP_KERNEL);
1141         if (buf == NULL)
1142                 return -ENOMEM;
1143         len = 0;
1144         len += scnprintf(buf + len, buf_len - len,
1145                          "roam_mode=%u\n\n"
1146                          "# roam_util bssid rssi rssidt last_rssi util bias\n",
1147                          le16_to_cpu(tbl->roam_mode));
1148
1149         for (i = 0; i < num_entries; i++) {
1150                 struct wmi_bss_roam_info *info = &tbl->info[i];
1151                 len += scnprintf(buf + len, buf_len - len,
1152                                  "%d %pM %d %d %d %d %d\n",
1153                                  a_sle32_to_cpu(info->roam_util), info->bssid,
1154                                  info->rssi, info->rssidt, info->last_rssi,
1155                                  info->util, info->bias);
1156         }
1157
1158         if (len > buf_len)
1159                 len = buf_len;
1160
1161         ret_cnt = simple_read_from_buffer(user_buf, count, ppos, buf, len);
1162
1163         kfree(buf);
1164         return ret_cnt;
1165 }
1166
1167 static const struct file_operations fops_roam_table = {
1168         .read = ath6kl_roam_table_read,
1169         .open = ath6kl_debugfs_open,
1170         .owner = THIS_MODULE,
1171         .llseek = default_llseek,
1172 };
1173
1174 static ssize_t ath6kl_force_roam_write(struct file *file,
1175                                        const char __user *user_buf,
1176                                        size_t count, loff_t *ppos)
1177 {
1178         struct ath6kl *ar = file->private_data;
1179         int ret;
1180         char buf[20];
1181         size_t len;
1182         u8 bssid[ETH_ALEN];
1183         int i;
1184         int addr[ETH_ALEN];
1185
1186         len = min(count, sizeof(buf) - 1);
1187         if (copy_from_user(buf, user_buf, len))
1188                 return -EFAULT;
1189         buf[len] = '\0';
1190
1191         if (sscanf(buf, "%02x:%02x:%02x:%02x:%02x:%02x",
1192                    &addr[0], &addr[1], &addr[2], &addr[3], &addr[4], &addr[5])
1193             != ETH_ALEN)
1194                 return -EINVAL;
1195         for (i = 0; i < ETH_ALEN; i++)
1196                 bssid[i] = addr[i];
1197
1198         ret = ath6kl_wmi_force_roam_cmd(ar->wmi, bssid);
1199         if (ret)
1200                 return ret;
1201
1202         return count;
1203 }
1204
1205 static const struct file_operations fops_force_roam = {
1206         .write = ath6kl_force_roam_write,
1207         .open = ath6kl_debugfs_open,
1208         .owner = THIS_MODULE,
1209         .llseek = default_llseek,
1210 };
1211
1212 static ssize_t ath6kl_roam_mode_write(struct file *file,
1213                                       const char __user *user_buf,
1214                                       size_t count, loff_t *ppos)
1215 {
1216         struct ath6kl *ar = file->private_data;
1217         int ret;
1218         char buf[20];
1219         size_t len;
1220         enum wmi_roam_mode mode;
1221
1222         len = min(count, sizeof(buf) - 1);
1223         if (copy_from_user(buf, user_buf, len))
1224                 return -EFAULT;
1225         buf[len] = '\0';
1226         if (len > 0 && buf[len - 1] == '\n')
1227                 buf[len - 1] = '\0';
1228
1229         if (strcasecmp(buf, "default") == 0)
1230                 mode = WMI_DEFAULT_ROAM_MODE;
1231         else if (strcasecmp(buf, "bssbias") == 0)
1232                 mode = WMI_HOST_BIAS_ROAM_MODE;
1233         else if (strcasecmp(buf, "lock") == 0)
1234                 mode = WMI_LOCK_BSS_MODE;
1235         else
1236                 return -EINVAL;
1237
1238         ret = ath6kl_wmi_set_roam_mode_cmd(ar->wmi, mode);
1239         if (ret)
1240                 return ret;
1241
1242         return count;
1243 }
1244
1245 static const struct file_operations fops_roam_mode = {
1246         .write = ath6kl_roam_mode_write,
1247         .open = ath6kl_debugfs_open,
1248         .owner = THIS_MODULE,
1249         .llseek = default_llseek,
1250 };
1251
1252 void ath6kl_debug_set_keepalive(struct ath6kl *ar, u8 keepalive)
1253 {
1254         ar->debug.keepalive = keepalive;
1255 }
1256
1257 static ssize_t ath6kl_keepalive_read(struct file *file, char __user *user_buf,
1258                                      size_t count, loff_t *ppos)
1259 {
1260         struct ath6kl *ar = file->private_data;
1261         char buf[16];
1262         int len;
1263
1264         len = snprintf(buf, sizeof(buf), "%u\n", ar->debug.keepalive);
1265
1266         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1267 }
1268
1269 static ssize_t ath6kl_keepalive_write(struct file *file,
1270                                       const char __user *user_buf,
1271                                       size_t count, loff_t *ppos)
1272 {
1273         struct ath6kl *ar = file->private_data;
1274         int ret;
1275         u8 val;
1276
1277         ret = kstrtou8_from_user(user_buf, count, 0, &val);
1278         if (ret)
1279                 return ret;
1280
1281         ret = ath6kl_wmi_set_keepalive_cmd(ar->wmi, 0, val);
1282         if (ret)
1283                 return ret;
1284
1285         return count;
1286 }
1287
1288 static const struct file_operations fops_keepalive = {
1289         .open = ath6kl_debugfs_open,
1290         .read = ath6kl_keepalive_read,
1291         .write = ath6kl_keepalive_write,
1292         .owner = THIS_MODULE,
1293         .llseek = default_llseek,
1294 };
1295
1296 void ath6kl_debug_set_disconnect_timeout(struct ath6kl *ar, u8 timeout)
1297 {
1298         ar->debug.disc_timeout = timeout;
1299 }
1300
1301 static ssize_t ath6kl_disconnect_timeout_read(struct file *file,
1302                                               char __user *user_buf,
1303                                               size_t count, loff_t *ppos)
1304 {
1305         struct ath6kl *ar = file->private_data;
1306         char buf[16];
1307         int len;
1308
1309         len = snprintf(buf, sizeof(buf), "%u\n", ar->debug.disc_timeout);
1310
1311         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1312 }
1313
1314 static ssize_t ath6kl_disconnect_timeout_write(struct file *file,
1315                                                const char __user *user_buf,
1316                                                size_t count, loff_t *ppos)
1317 {
1318         struct ath6kl *ar = file->private_data;
1319         int ret;
1320         u8 val;
1321
1322         ret = kstrtou8_from_user(user_buf, count, 0, &val);
1323         if (ret)
1324                 return ret;
1325
1326         ret = ath6kl_wmi_disctimeout_cmd(ar->wmi, 0, val);
1327         if (ret)
1328                 return ret;
1329
1330         return count;
1331 }
1332
1333 static const struct file_operations fops_disconnect_timeout = {
1334         .open = ath6kl_debugfs_open,
1335         .read = ath6kl_disconnect_timeout_read,
1336         .write = ath6kl_disconnect_timeout_write,
1337         .owner = THIS_MODULE,
1338         .llseek = default_llseek,
1339 };
1340
1341 static ssize_t ath6kl_create_qos_write(struct file *file,
1342                                                 const char __user *user_buf,
1343                                                 size_t count, loff_t *ppos)
1344 {
1345
1346         struct ath6kl *ar = file->private_data;
1347         struct ath6kl_vif *vif;
1348         char buf[200];
1349         ssize_t len;
1350         char *sptr, *token;
1351         struct wmi_create_pstream_cmd pstream;
1352         u32 val32;
1353         u16 val16;
1354
1355         vif = ath6kl_vif_first(ar);
1356         if (!vif)
1357                 return -EIO;
1358
1359         len = min(count, sizeof(buf) - 1);
1360         if (copy_from_user(buf, user_buf, len))
1361                 return -EFAULT;
1362         buf[len] = '\0';
1363         sptr = buf;
1364
1365         token = strsep(&sptr, " ");
1366         if (!token)
1367                 return -EINVAL;
1368         if (kstrtou8(token, 0, &pstream.user_pri))
1369                 return -EINVAL;
1370
1371         token = strsep(&sptr, " ");
1372         if (!token)
1373                 return -EINVAL;
1374         if (kstrtou8(token, 0, &pstream.traffic_direc))
1375                 return -EINVAL;
1376
1377         token = strsep(&sptr, " ");
1378         if (!token)
1379                 return -EINVAL;
1380         if (kstrtou8(token, 0, &pstream.traffic_class))
1381                 return -EINVAL;
1382
1383         token = strsep(&sptr, " ");
1384         if (!token)
1385                 return -EINVAL;
1386         if (kstrtou8(token, 0, &pstream.traffic_type))
1387                 return -EINVAL;
1388
1389         token = strsep(&sptr, " ");
1390         if (!token)
1391                 return -EINVAL;
1392         if (kstrtou8(token, 0, &pstream.voice_psc_cap))
1393                 return -EINVAL;
1394
1395         token = strsep(&sptr, " ");
1396         if (!token)
1397                 return -EINVAL;
1398         if (kstrtou32(token, 0, &val32))
1399                 return -EINVAL;
1400         pstream.min_service_int = cpu_to_le32(val32);
1401
1402         token = strsep(&sptr, " ");
1403         if (!token)
1404                 return -EINVAL;
1405         if (kstrtou32(token, 0, &val32))
1406                 return -EINVAL;
1407         pstream.max_service_int = cpu_to_le32(val32);
1408
1409         token = strsep(&sptr, " ");
1410         if (!token)
1411                 return -EINVAL;
1412         if (kstrtou32(token, 0, &val32))
1413                 return -EINVAL;
1414         pstream.inactivity_int = cpu_to_le32(val32);
1415
1416         token = strsep(&sptr, " ");
1417         if (!token)
1418                 return -EINVAL;
1419         if (kstrtou32(token, 0, &val32))
1420                 return -EINVAL;
1421         pstream.suspension_int = cpu_to_le32(val32);
1422
1423         token = strsep(&sptr, " ");
1424         if (!token)
1425                 return -EINVAL;
1426         if (kstrtou32(token, 0, &val32))
1427                 return -EINVAL;
1428         pstream.service_start_time = cpu_to_le32(val32);
1429
1430         token = strsep(&sptr, " ");
1431         if (!token)
1432                 return -EINVAL;
1433         if (kstrtou8(token, 0, &pstream.tsid))
1434                 return -EINVAL;
1435
1436         token = strsep(&sptr, " ");
1437         if (!token)
1438                 return -EINVAL;
1439         if (kstrtou16(token, 0, &val16))
1440                 return -EINVAL;
1441         pstream.nominal_msdu = cpu_to_le16(val16);
1442
1443         token = strsep(&sptr, " ");
1444         if (!token)
1445                 return -EINVAL;
1446         if (kstrtou16(token, 0, &val16))
1447                 return -EINVAL;
1448         pstream.max_msdu = cpu_to_le16(val16);
1449
1450         token = strsep(&sptr, " ");
1451         if (!token)
1452                 return -EINVAL;
1453         if (kstrtou32(token, 0, &val32))
1454                 return -EINVAL;
1455         pstream.min_data_rate = cpu_to_le32(val32);
1456
1457         token = strsep(&sptr, " ");
1458         if (!token)
1459                 return -EINVAL;
1460         if (kstrtou32(token, 0, &val32))
1461                 return -EINVAL;
1462         pstream.mean_data_rate = cpu_to_le32(val32);
1463
1464         token = strsep(&sptr, " ");
1465         if (!token)
1466                 return -EINVAL;
1467         if (kstrtou32(token, 0, &val32))
1468                 return -EINVAL;
1469         pstream.peak_data_rate = cpu_to_le32(val32);
1470
1471         token = strsep(&sptr, " ");
1472         if (!token)
1473                 return -EINVAL;
1474         if (kstrtou32(token, 0, &val32))
1475                 return -EINVAL;
1476         pstream.max_burst_size = cpu_to_le32(val32);
1477
1478         token = strsep(&sptr, " ");
1479         if (!token)
1480                 return -EINVAL;
1481         if (kstrtou32(token, 0, &val32))
1482                 return -EINVAL;
1483         pstream.delay_bound = cpu_to_le32(val32);
1484
1485         token = strsep(&sptr, " ");
1486         if (!token)
1487                 return -EINVAL;
1488         if (kstrtou32(token, 0, &val32))
1489                 return -EINVAL;
1490         pstream.min_phy_rate = cpu_to_le32(val32);
1491
1492         token = strsep(&sptr, " ");
1493         if (!token)
1494                 return -EINVAL;
1495         if (kstrtou32(token, 0, &val32))
1496                 return -EINVAL;
1497         pstream.sba = cpu_to_le32(val32);
1498
1499         token = strsep(&sptr, " ");
1500         if (!token)
1501                 return -EINVAL;
1502         if (kstrtou32(token, 0, &val32))
1503                 return -EINVAL;
1504         pstream.medium_time = cpu_to_le32(val32);
1505
1506         pstream.nominal_phy = le32_to_cpu(pstream.min_phy_rate) / 1000000;
1507
1508         ath6kl_wmi_create_pstream_cmd(ar->wmi, vif->fw_vif_idx, &pstream);
1509
1510         return count;
1511 }
1512
1513 static const struct file_operations fops_create_qos = {
1514         .write = ath6kl_create_qos_write,
1515         .open = ath6kl_debugfs_open,
1516         .owner = THIS_MODULE,
1517         .llseek = default_llseek,
1518 };
1519
1520 static ssize_t ath6kl_delete_qos_write(struct file *file,
1521                                 const char __user *user_buf,
1522                                 size_t count, loff_t *ppos)
1523 {
1524
1525         struct ath6kl *ar = file->private_data;
1526         struct ath6kl_vif *vif;
1527         char buf[100];
1528         ssize_t len;
1529         char *sptr, *token;
1530         u8 traffic_class;
1531         u8 tsid;
1532
1533         vif = ath6kl_vif_first(ar);
1534         if (!vif)
1535                 return -EIO;
1536
1537         len = min(count, sizeof(buf) - 1);
1538         if (copy_from_user(buf, user_buf, len))
1539                 return -EFAULT;
1540         buf[len] = '\0';
1541         sptr = buf;
1542
1543         token = strsep(&sptr, " ");
1544         if (!token)
1545                 return -EINVAL;
1546         if (kstrtou8(token, 0, &traffic_class))
1547                 return -EINVAL;
1548
1549         token = strsep(&sptr, " ");
1550         if (!token)
1551                 return -EINVAL;
1552         if (kstrtou8(token, 0, &tsid))
1553                 return -EINVAL;
1554
1555         ath6kl_wmi_delete_pstream_cmd(ar->wmi, vif->fw_vif_idx,
1556                                       traffic_class, tsid);
1557
1558         return count;
1559 }
1560
1561 static const struct file_operations fops_delete_qos = {
1562         .write = ath6kl_delete_qos_write,
1563         .open = ath6kl_debugfs_open,
1564         .owner = THIS_MODULE,
1565         .llseek = default_llseek,
1566 };
1567
1568 static ssize_t ath6kl_bgscan_int_write(struct file *file,
1569                                 const char __user *user_buf,
1570                                 size_t count, loff_t *ppos)
1571 {
1572         struct ath6kl *ar = file->private_data;
1573         u16 bgscan_int;
1574         char buf[32];
1575         ssize_t len;
1576
1577         len = min(count, sizeof(buf) - 1);
1578         if (copy_from_user(buf, user_buf, len))
1579                 return -EFAULT;
1580
1581         buf[len] = '\0';
1582         if (kstrtou16(buf, 0, &bgscan_int))
1583                 return -EINVAL;
1584
1585         if (bgscan_int == 0)
1586                 bgscan_int = 0xffff;
1587
1588         ath6kl_wmi_scanparams_cmd(ar->wmi, 0, 0, 0, bgscan_int, 0, 0, 0, 3,
1589                                   0, 0, 0);
1590
1591         return count;
1592 }
1593
1594 static const struct file_operations fops_bgscan_int = {
1595         .write = ath6kl_bgscan_int_write,
1596         .open = ath6kl_debugfs_open,
1597         .owner = THIS_MODULE,
1598         .llseek = default_llseek,
1599 };
1600
1601 static ssize_t ath6kl_listen_int_write(struct file *file,
1602                                        const char __user *user_buf,
1603                                        size_t count, loff_t *ppos)
1604 {
1605         struct ath6kl *ar = file->private_data;
1606         struct ath6kl_vif *vif;
1607         u16 listen_interval;
1608         char buf[32];
1609         ssize_t len;
1610
1611         vif = ath6kl_vif_first(ar);
1612         if (!vif)
1613                 return -EIO;
1614
1615         len = min(count, sizeof(buf) - 1);
1616         if (copy_from_user(buf, user_buf, len))
1617                 return -EFAULT;
1618
1619         buf[len] = '\0';
1620         if (kstrtou16(buf, 0, &listen_interval))
1621                 return -EINVAL;
1622
1623         if ((listen_interval < 15) || (listen_interval > 3000))
1624                 return -EINVAL;
1625
1626         vif->listen_intvl_t = listen_interval;
1627         ath6kl_wmi_listeninterval_cmd(ar->wmi, vif->fw_vif_idx,
1628                                       vif->listen_intvl_t, 0);
1629
1630         return count;
1631 }
1632
1633 static ssize_t ath6kl_listen_int_read(struct file *file,
1634                                       char __user *user_buf,
1635                                       size_t count, loff_t *ppos)
1636 {
1637         struct ath6kl *ar = file->private_data;
1638         struct ath6kl_vif *vif;
1639         char buf[32];
1640         int len;
1641
1642         vif = ath6kl_vif_first(ar);
1643         if (!vif)
1644                 return -EIO;
1645
1646         len = scnprintf(buf, sizeof(buf), "%u\n", vif->listen_intvl_t);
1647
1648         return simple_read_from_buffer(user_buf, count, ppos, buf, len);
1649 }
1650
1651 static const struct file_operations fops_listen_int = {
1652         .read = ath6kl_listen_int_read,
1653         .write = ath6kl_listen_int_write,
1654         .open = ath6kl_debugfs_open,
1655         .owner = THIS_MODULE,
1656         .llseek = default_llseek,
1657 };
1658
1659 static ssize_t ath6kl_power_params_write(struct file *file,
1660                                                 const char __user *user_buf,
1661                                                 size_t count, loff_t *ppos)
1662 {
1663         struct ath6kl *ar = file->private_data;
1664         u8 buf[100];
1665         unsigned int len = 0;
1666         char *sptr, *token;
1667         u16 idle_period, ps_poll_num, dtim,
1668                 tx_wakeup, num_tx;
1669
1670         len = min(count, sizeof(buf) - 1);
1671         if (copy_from_user(buf, user_buf, len))
1672                 return -EFAULT;
1673         buf[len] = '\0';
1674         sptr = buf;
1675
1676         token = strsep(&sptr, " ");
1677         if (!token)
1678                 return -EINVAL;
1679         if (kstrtou16(token, 0, &idle_period))
1680                 return -EINVAL;
1681
1682         token = strsep(&sptr, " ");
1683         if (!token)
1684                 return -EINVAL;
1685         if (kstrtou16(token, 0, &ps_poll_num))
1686                 return -EINVAL;
1687
1688         token = strsep(&sptr, " ");
1689         if (!token)
1690                 return -EINVAL;
1691         if (kstrtou16(token, 0, &dtim))
1692                 return -EINVAL;
1693
1694         token = strsep(&sptr, " ");
1695         if (!token)
1696                 return -EINVAL;
1697         if (kstrtou16(token, 0, &tx_wakeup))
1698                 return -EINVAL;
1699
1700         token = strsep(&sptr, " ");
1701         if (!token)
1702                 return -EINVAL;
1703         if (kstrtou16(token, 0, &num_tx))
1704                 return -EINVAL;
1705
1706         ath6kl_wmi_pmparams_cmd(ar->wmi, 0, idle_period, ps_poll_num,
1707                                 dtim, tx_wakeup, num_tx, 0);
1708
1709         return count;
1710 }
1711
1712 static const struct file_operations fops_power_params = {
1713         .write = ath6kl_power_params_write,
1714         .open = ath6kl_debugfs_open,
1715         .owner = THIS_MODULE,
1716         .llseek = default_llseek,
1717 };
1718
1719 void ath6kl_debug_init(struct ath6kl *ar)
1720 {
1721         skb_queue_head_init(&ar->debug.fwlog_queue);
1722         init_completion(&ar->debug.fwlog_completion);
1723
1724         /*
1725          * Actually we are lying here but don't know how to read the mask
1726          * value from the firmware.
1727          */
1728         ar->debug.fwlog_mask = 0;
1729 }
1730
1731 /*
1732  * Initialisation needs to happen in two stages as fwlog events can come
1733  * before cfg80211 is initialised, and debugfs depends on cfg80211
1734  * initialisation.
1735  */
1736 int ath6kl_debug_init_fs(struct ath6kl *ar)
1737 {
1738         ar->debugfs_phy = debugfs_create_dir("ath6kl",
1739                                              ar->wiphy->debugfsdir);
1740         if (!ar->debugfs_phy)
1741                 return -ENOMEM;
1742
1743         debugfs_create_file("tgt_stats", S_IRUSR, ar->debugfs_phy, ar,
1744                             &fops_tgt_stats);
1745
1746         debugfs_create_file("credit_dist_stats", S_IRUSR, ar->debugfs_phy, ar,
1747                             &fops_credit_dist_stats);
1748
1749         debugfs_create_file("endpoint_stats", S_IRUSR | S_IWUSR,
1750                             ar->debugfs_phy, ar, &fops_endpoint_stats);
1751
1752         debugfs_create_file("fwlog", S_IRUSR, ar->debugfs_phy, ar,
1753                             &fops_fwlog);
1754
1755         debugfs_create_file("fwlog_block", S_IRUSR, ar->debugfs_phy, ar,
1756                             &fops_fwlog_block);
1757
1758         debugfs_create_file("fwlog_mask", S_IRUSR | S_IWUSR, ar->debugfs_phy,
1759                             ar, &fops_fwlog_mask);
1760
1761         debugfs_create_file("reg_addr", S_IRUSR | S_IWUSR, ar->debugfs_phy, ar,
1762                             &fops_diag_reg_read);
1763
1764         debugfs_create_file("reg_dump", S_IRUSR, ar->debugfs_phy, ar,
1765                             &fops_reg_dump);
1766
1767         debugfs_create_file("lrssi_roam_threshold", S_IRUSR | S_IWUSR,
1768                             ar->debugfs_phy, ar, &fops_lrssi_roam_threshold);
1769
1770         debugfs_create_file("reg_write", S_IRUSR | S_IWUSR,
1771                             ar->debugfs_phy, ar, &fops_diag_reg_write);
1772
1773         debugfs_create_file("war_stats", S_IRUSR, ar->debugfs_phy, ar,
1774                             &fops_war_stats);
1775
1776         debugfs_create_file("roam_table", S_IRUSR, ar->debugfs_phy, ar,
1777                             &fops_roam_table);
1778
1779         debugfs_create_file("force_roam", S_IWUSR, ar->debugfs_phy, ar,
1780                             &fops_force_roam);
1781
1782         debugfs_create_file("roam_mode", S_IWUSR, ar->debugfs_phy, ar,
1783                             &fops_roam_mode);
1784
1785         debugfs_create_file("keepalive", S_IRUSR | S_IWUSR, ar->debugfs_phy, ar,
1786                             &fops_keepalive);
1787
1788         debugfs_create_file("disconnect_timeout", S_IRUSR | S_IWUSR,
1789                             ar->debugfs_phy, ar, &fops_disconnect_timeout);
1790
1791         debugfs_create_file("create_qos", S_IWUSR, ar->debugfs_phy, ar,
1792                             &fops_create_qos);
1793
1794         debugfs_create_file("delete_qos", S_IWUSR, ar->debugfs_phy, ar,
1795                             &fops_delete_qos);
1796
1797         debugfs_create_file("bgscan_interval", S_IWUSR,
1798                             ar->debugfs_phy, ar, &fops_bgscan_int);
1799
1800         debugfs_create_file("listen_interval", S_IRUSR | S_IWUSR,
1801                             ar->debugfs_phy, ar, &fops_listen_int);
1802
1803         debugfs_create_file("power_params", S_IWUSR, ar->debugfs_phy, ar,
1804                             &fops_power_params);
1805
1806         return 0;
1807 }
1808
1809 void ath6kl_debug_cleanup(struct ath6kl *ar)
1810 {
1811         skb_queue_purge(&ar->debug.fwlog_queue);
1812         kfree(ar->debug.roam_tbl);
1813 }
1814
1815 #endif