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