1 /* 2 * Copyright (c) 2012-2017 Qualcomm Atheros, Inc. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for any 5 * purpose with or without fee is hereby granted, provided that the above 6 * copyright notice and this permission notice appear in all copies. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 15 */ 16 17 #include <linux/module.h> 18 #include <linux/debugfs.h> 19 #include <linux/seq_file.h> 20 #include <linux/pci.h> 21 #include <linux/rtnetlink.h> 22 #include <linux/power_supply.h> 23 #include "wil6210.h" 24 #include "wmi.h" 25 #include "txrx.h" 26 #include "pmc.h" 27 28 /* Nasty hack. Better have per device instances */ 29 static u32 mem_addr; 30 static u32 dbg_txdesc_index; 31 static u32 dbg_vring_index; /* 24+ for Rx, 0..23 for Tx */ 32 33 enum dbg_off_type { 34 doff_u32 = 0, 35 doff_x32 = 1, 36 doff_ulong = 2, 37 doff_io32 = 3, 38 doff_u8 = 4 39 }; 40 41 /* offset to "wil" */ 42 struct dbg_off { 43 const char *name; 44 umode_t mode; 45 ulong off; 46 enum dbg_off_type type; 47 }; 48 49 static void wil_print_vring(struct seq_file *s, struct wil6210_priv *wil, 50 const char *name, struct vring *vring, 51 char _s, char _h) 52 { 53 void __iomem *x = wmi_addr(wil, vring->hwtail); 54 u32 v; 55 56 seq_printf(s, "VRING %s = {\n", name); 57 seq_printf(s, " pa = %pad\n", &vring->pa); 58 seq_printf(s, " va = 0x%p\n", vring->va); 59 seq_printf(s, " size = %d\n", vring->size); 60 seq_printf(s, " swtail = %d\n", vring->swtail); 61 seq_printf(s, " swhead = %d\n", vring->swhead); 62 seq_printf(s, " hwtail = [0x%08x] -> ", vring->hwtail); 63 if (x) { 64 v = readl(x); 65 seq_printf(s, "0x%08x = %d\n", v, v); 66 } else { 67 seq_puts(s, "???\n"); 68 } 69 70 if (vring->va && (vring->size <= (1 << WIL_RING_SIZE_ORDER_MAX))) { 71 uint i; 72 73 for (i = 0; i < vring->size; i++) { 74 volatile struct vring_tx_desc *d = &vring->va[i].tx; 75 76 if ((i % 128) == 0 && (i != 0)) 77 seq_puts(s, "\n"); 78 seq_printf(s, "%c", (d->dma.status & BIT(0)) ? 79 _s : (vring->ctx[i].skb ? _h : 'h')); 80 } 81 seq_puts(s, "\n"); 82 } 83 seq_puts(s, "}\n"); 84 } 85 86 static int wil_vring_debugfs_show(struct seq_file *s, void *data) 87 { 88 uint i; 89 struct wil6210_priv *wil = s->private; 90 91 wil_print_vring(s, wil, "rx", &wil->vring_rx, 'S', '_'); 92 93 for (i = 0; i < ARRAY_SIZE(wil->vring_tx); i++) { 94 struct vring *vring = &wil->vring_tx[i]; 95 struct vring_tx_data *txdata = &wil->vring_tx_data[i]; 96 97 if (vring->va) { 98 int cid = wil->vring2cid_tid[i][0]; 99 int tid = wil->vring2cid_tid[i][1]; 100 u32 swhead = vring->swhead; 101 u32 swtail = vring->swtail; 102 int used = (vring->size + swhead - swtail) 103 % vring->size; 104 int avail = vring->size - used - 1; 105 char name[10]; 106 char sidle[10]; 107 /* performance monitoring */ 108 cycles_t now = get_cycles(); 109 uint64_t idle = txdata->idle * 100; 110 uint64_t total = now - txdata->begin; 111 112 if (total != 0) { 113 do_div(idle, total); 114 snprintf(sidle, sizeof(sidle), "%3d%%", 115 (int)idle); 116 } else { 117 snprintf(sidle, sizeof(sidle), "N/A"); 118 } 119 txdata->begin = now; 120 txdata->idle = 0ULL; 121 122 snprintf(name, sizeof(name), "tx_%2d", i); 123 124 if (cid < WIL6210_MAX_CID) 125 seq_printf(s, 126 "\n%pM CID %d TID %d 1x%s BACK([%u] %u TU A%s) [%3d|%3d] idle %s\n", 127 wil->sta[cid].addr, cid, tid, 128 txdata->dot1x_open ? "+" : "-", 129 txdata->agg_wsize, 130 txdata->agg_timeout, 131 txdata->agg_amsdu ? "+" : "-", 132 used, avail, sidle); 133 else 134 seq_printf(s, 135 "\nBroadcast 1x%s [%3d|%3d] idle %s\n", 136 txdata->dot1x_open ? "+" : "-", 137 used, avail, sidle); 138 139 wil_print_vring(s, wil, name, vring, '_', 'H'); 140 } 141 } 142 143 return 0; 144 } 145 146 static int wil_vring_seq_open(struct inode *inode, struct file *file) 147 { 148 return single_open(file, wil_vring_debugfs_show, inode->i_private); 149 } 150 151 static const struct file_operations fops_vring = { 152 .open = wil_vring_seq_open, 153 .release = single_release, 154 .read = seq_read, 155 .llseek = seq_lseek, 156 }; 157 158 static void wil_seq_hexdump(struct seq_file *s, void *p, int len, 159 const char *prefix) 160 { 161 seq_hex_dump(s, prefix, DUMP_PREFIX_NONE, 16, 1, p, len, false); 162 } 163 164 static void wil_print_ring(struct seq_file *s, const char *prefix, 165 void __iomem *off) 166 { 167 struct wil6210_priv *wil = s->private; 168 struct wil6210_mbox_ring r; 169 int rsize; 170 uint i; 171 172 wil_halp_vote(wil); 173 174 wil_memcpy_fromio_32(&r, off, sizeof(r)); 175 wil_mbox_ring_le2cpus(&r); 176 /* 177 * we just read memory block from NIC. This memory may be 178 * garbage. Check validity before using it. 179 */ 180 rsize = r.size / sizeof(struct wil6210_mbox_ring_desc); 181 182 seq_printf(s, "ring %s = {\n", prefix); 183 seq_printf(s, " base = 0x%08x\n", r.base); 184 seq_printf(s, " size = 0x%04x bytes -> %d entries\n", r.size, rsize); 185 seq_printf(s, " tail = 0x%08x\n", r.tail); 186 seq_printf(s, " head = 0x%08x\n", r.head); 187 seq_printf(s, " entry size = %d\n", r.entry_size); 188 189 if (r.size % sizeof(struct wil6210_mbox_ring_desc)) { 190 seq_printf(s, " ??? size is not multiple of %zd, garbage?\n", 191 sizeof(struct wil6210_mbox_ring_desc)); 192 goto out; 193 } 194 195 if (!wmi_addr(wil, r.base) || 196 !wmi_addr(wil, r.tail) || 197 !wmi_addr(wil, r.head)) { 198 seq_puts(s, " ??? pointers are garbage?\n"); 199 goto out; 200 } 201 202 for (i = 0; i < rsize; i++) { 203 struct wil6210_mbox_ring_desc d; 204 struct wil6210_mbox_hdr hdr; 205 size_t delta = i * sizeof(d); 206 void __iomem *x = wil->csr + HOSTADDR(r.base) + delta; 207 208 wil_memcpy_fromio_32(&d, x, sizeof(d)); 209 210 seq_printf(s, " [%2x] %s %s%s 0x%08x", i, 211 d.sync ? "F" : "E", 212 (r.tail - r.base == delta) ? "t" : " ", 213 (r.head - r.base == delta) ? "h" : " ", 214 le32_to_cpu(d.addr)); 215 if (0 == wmi_read_hdr(wil, d.addr, &hdr)) { 216 u16 len = le16_to_cpu(hdr.len); 217 218 seq_printf(s, " -> %04x %04x %04x %02x\n", 219 le16_to_cpu(hdr.seq), len, 220 le16_to_cpu(hdr.type), hdr.flags); 221 if (len <= MAX_MBOXITEM_SIZE) { 222 unsigned char databuf[MAX_MBOXITEM_SIZE]; 223 void __iomem *src = wmi_buffer(wil, d.addr) + 224 sizeof(struct wil6210_mbox_hdr); 225 /* 226 * No need to check @src for validity - 227 * we already validated @d.addr while 228 * reading header 229 */ 230 wil_memcpy_fromio_32(databuf, src, len); 231 wil_seq_hexdump(s, databuf, len, " : "); 232 } 233 } else { 234 seq_puts(s, "\n"); 235 } 236 } 237 out: 238 seq_puts(s, "}\n"); 239 wil_halp_unvote(wil); 240 } 241 242 static int wil_mbox_debugfs_show(struct seq_file *s, void *data) 243 { 244 struct wil6210_priv *wil = s->private; 245 int ret; 246 247 ret = wil_pm_runtime_get(wil); 248 if (ret < 0) 249 return ret; 250 251 wil_print_ring(s, "tx", wil->csr + HOST_MBOX + 252 offsetof(struct wil6210_mbox_ctl, tx)); 253 wil_print_ring(s, "rx", wil->csr + HOST_MBOX + 254 offsetof(struct wil6210_mbox_ctl, rx)); 255 256 wil_pm_runtime_put(wil); 257 258 return 0; 259 } 260 261 static int wil_mbox_seq_open(struct inode *inode, struct file *file) 262 { 263 return single_open(file, wil_mbox_debugfs_show, inode->i_private); 264 } 265 266 static const struct file_operations fops_mbox = { 267 .open = wil_mbox_seq_open, 268 .release = single_release, 269 .read = seq_read, 270 .llseek = seq_lseek, 271 }; 272 273 static int wil_debugfs_iomem_x32_set(void *data, u64 val) 274 { 275 struct wil_debugfs_iomem_data *d = (struct 276 wil_debugfs_iomem_data *)data; 277 struct wil6210_priv *wil = d->wil; 278 int ret; 279 280 ret = wil_pm_runtime_get(wil); 281 if (ret < 0) 282 return ret; 283 284 writel(val, (void __iomem *)d->offset); 285 wmb(); /* make sure write propagated to HW */ 286 287 wil_pm_runtime_put(wil); 288 289 return 0; 290 } 291 292 static int wil_debugfs_iomem_x32_get(void *data, u64 *val) 293 { 294 struct wil_debugfs_iomem_data *d = (struct 295 wil_debugfs_iomem_data *)data; 296 struct wil6210_priv *wil = d->wil; 297 int ret; 298 299 ret = wil_pm_runtime_get(wil); 300 if (ret < 0) 301 return ret; 302 303 *val = readl((void __iomem *)d->offset); 304 305 wil_pm_runtime_put(wil); 306 307 return 0; 308 } 309 310 DEFINE_SIMPLE_ATTRIBUTE(fops_iomem_x32, wil_debugfs_iomem_x32_get, 311 wil_debugfs_iomem_x32_set, "0x%08llx\n"); 312 313 static struct dentry *wil_debugfs_create_iomem_x32(const char *name, 314 umode_t mode, 315 struct dentry *parent, 316 void *value, 317 struct wil6210_priv *wil) 318 { 319 struct dentry *file; 320 struct wil_debugfs_iomem_data *data = &wil->dbg_data.data_arr[ 321 wil->dbg_data.iomem_data_count]; 322 323 data->wil = wil; 324 data->offset = value; 325 326 file = debugfs_create_file(name, mode, parent, data, &fops_iomem_x32); 327 if (!IS_ERR_OR_NULL(file)) 328 wil->dbg_data.iomem_data_count++; 329 330 return file; 331 } 332 333 static int wil_debugfs_ulong_set(void *data, u64 val) 334 { 335 *(ulong *)data = val; 336 return 0; 337 } 338 339 static int wil_debugfs_ulong_get(void *data, u64 *val) 340 { 341 *val = *(ulong *)data; 342 return 0; 343 } 344 345 DEFINE_SIMPLE_ATTRIBUTE(wil_fops_ulong, wil_debugfs_ulong_get, 346 wil_debugfs_ulong_set, "0x%llx\n"); 347 348 static struct dentry *wil_debugfs_create_ulong(const char *name, umode_t mode, 349 struct dentry *parent, 350 ulong *value) 351 { 352 return debugfs_create_file(name, mode, parent, value, &wil_fops_ulong); 353 } 354 355 /** 356 * wil6210_debugfs_init_offset - create set of debugfs files 357 * @wil - driver's context, used for printing 358 * @dbg - directory on the debugfs, where files will be created 359 * @base - base address used in address calculation 360 * @tbl - table with file descriptions. Should be terminated with empty element. 361 * 362 * Creates files accordingly to the @tbl. 363 */ 364 static void wil6210_debugfs_init_offset(struct wil6210_priv *wil, 365 struct dentry *dbg, void *base, 366 const struct dbg_off * const tbl) 367 { 368 int i; 369 370 for (i = 0; tbl[i].name; i++) { 371 struct dentry *f; 372 373 switch (tbl[i].type) { 374 case doff_u32: 375 f = debugfs_create_u32(tbl[i].name, tbl[i].mode, dbg, 376 base + tbl[i].off); 377 break; 378 case doff_x32: 379 f = debugfs_create_x32(tbl[i].name, tbl[i].mode, dbg, 380 base + tbl[i].off); 381 break; 382 case doff_ulong: 383 f = wil_debugfs_create_ulong(tbl[i].name, tbl[i].mode, 384 dbg, base + tbl[i].off); 385 break; 386 case doff_io32: 387 f = wil_debugfs_create_iomem_x32(tbl[i].name, 388 tbl[i].mode, dbg, 389 base + tbl[i].off, 390 wil); 391 break; 392 case doff_u8: 393 f = debugfs_create_u8(tbl[i].name, tbl[i].mode, dbg, 394 base + tbl[i].off); 395 break; 396 default: 397 f = ERR_PTR(-EINVAL); 398 } 399 if (IS_ERR_OR_NULL(f)) 400 wil_err(wil, "Create file \"%s\": err %ld\n", 401 tbl[i].name, PTR_ERR(f)); 402 } 403 } 404 405 static const struct dbg_off isr_off[] = { 406 {"ICC", 0644, offsetof(struct RGF_ICR, ICC), doff_io32}, 407 {"ICR", 0644, offsetof(struct RGF_ICR, ICR), doff_io32}, 408 {"ICM", 0644, offsetof(struct RGF_ICR, ICM), doff_io32}, 409 {"ICS", 0244, offsetof(struct RGF_ICR, ICS), doff_io32}, 410 {"IMV", 0644, offsetof(struct RGF_ICR, IMV), doff_io32}, 411 {"IMS", 0244, offsetof(struct RGF_ICR, IMS), doff_io32}, 412 {"IMC", 0244, offsetof(struct RGF_ICR, IMC), doff_io32}, 413 {}, 414 }; 415 416 static int wil6210_debugfs_create_ISR(struct wil6210_priv *wil, 417 const char *name, 418 struct dentry *parent, u32 off) 419 { 420 struct dentry *d = debugfs_create_dir(name, parent); 421 422 if (IS_ERR_OR_NULL(d)) 423 return -ENODEV; 424 425 wil6210_debugfs_init_offset(wil, d, (void * __force)wil->csr + off, 426 isr_off); 427 428 return 0; 429 } 430 431 static const struct dbg_off pseudo_isr_off[] = { 432 {"CAUSE", 0444, HOSTADDR(RGF_DMA_PSEUDO_CAUSE), doff_io32}, 433 {"MASK_SW", 0444, HOSTADDR(RGF_DMA_PSEUDO_CAUSE_MASK_SW), doff_io32}, 434 {"MASK_FW", 0444, HOSTADDR(RGF_DMA_PSEUDO_CAUSE_MASK_FW), doff_io32}, 435 {}, 436 }; 437 438 static int wil6210_debugfs_create_pseudo_ISR(struct wil6210_priv *wil, 439 struct dentry *parent) 440 { 441 struct dentry *d = debugfs_create_dir("PSEUDO_ISR", parent); 442 443 if (IS_ERR_OR_NULL(d)) 444 return -ENODEV; 445 446 wil6210_debugfs_init_offset(wil, d, (void * __force)wil->csr, 447 pseudo_isr_off); 448 449 return 0; 450 } 451 452 static const struct dbg_off lgc_itr_cnt_off[] = { 453 {"TRSH", 0644, HOSTADDR(RGF_DMA_ITR_CNT_TRSH), doff_io32}, 454 {"DATA", 0644, HOSTADDR(RGF_DMA_ITR_CNT_DATA), doff_io32}, 455 {"CTL", 0644, HOSTADDR(RGF_DMA_ITR_CNT_CRL), doff_io32}, 456 {}, 457 }; 458 459 static const struct dbg_off tx_itr_cnt_off[] = { 460 {"TRSH", 0644, HOSTADDR(RGF_DMA_ITR_TX_CNT_TRSH), 461 doff_io32}, 462 {"DATA", 0644, HOSTADDR(RGF_DMA_ITR_TX_CNT_DATA), 463 doff_io32}, 464 {"CTL", 0644, HOSTADDR(RGF_DMA_ITR_TX_CNT_CTL), 465 doff_io32}, 466 {"IDL_TRSH", 0644, HOSTADDR(RGF_DMA_ITR_TX_IDL_CNT_TRSH), 467 doff_io32}, 468 {"IDL_DATA", 0644, HOSTADDR(RGF_DMA_ITR_TX_IDL_CNT_DATA), 469 doff_io32}, 470 {"IDL_CTL", 0644, HOSTADDR(RGF_DMA_ITR_TX_IDL_CNT_CTL), 471 doff_io32}, 472 {}, 473 }; 474 475 static const struct dbg_off rx_itr_cnt_off[] = { 476 {"TRSH", 0644, HOSTADDR(RGF_DMA_ITR_RX_CNT_TRSH), 477 doff_io32}, 478 {"DATA", 0644, HOSTADDR(RGF_DMA_ITR_RX_CNT_DATA), 479 doff_io32}, 480 {"CTL", 0644, HOSTADDR(RGF_DMA_ITR_RX_CNT_CTL), 481 doff_io32}, 482 {"IDL_TRSH", 0644, HOSTADDR(RGF_DMA_ITR_RX_IDL_CNT_TRSH), 483 doff_io32}, 484 {"IDL_DATA", 0644, HOSTADDR(RGF_DMA_ITR_RX_IDL_CNT_DATA), 485 doff_io32}, 486 {"IDL_CTL", 0644, HOSTADDR(RGF_DMA_ITR_RX_IDL_CNT_CTL), 487 doff_io32}, 488 {}, 489 }; 490 491 static int wil6210_debugfs_create_ITR_CNT(struct wil6210_priv *wil, 492 struct dentry *parent) 493 { 494 struct dentry *d, *dtx, *drx; 495 496 d = debugfs_create_dir("ITR_CNT", parent); 497 if (IS_ERR_OR_NULL(d)) 498 return -ENODEV; 499 500 dtx = debugfs_create_dir("TX", d); 501 drx = debugfs_create_dir("RX", d); 502 if (IS_ERR_OR_NULL(dtx) || IS_ERR_OR_NULL(drx)) 503 return -ENODEV; 504 505 wil6210_debugfs_init_offset(wil, d, (void * __force)wil->csr, 506 lgc_itr_cnt_off); 507 508 wil6210_debugfs_init_offset(wil, dtx, (void * __force)wil->csr, 509 tx_itr_cnt_off); 510 511 wil6210_debugfs_init_offset(wil, drx, (void * __force)wil->csr, 512 rx_itr_cnt_off); 513 return 0; 514 } 515 516 static int wil_memread_debugfs_show(struct seq_file *s, void *data) 517 { 518 struct wil6210_priv *wil = s->private; 519 void __iomem *a; 520 int ret; 521 522 ret = wil_pm_runtime_get(wil); 523 if (ret < 0) 524 return ret; 525 526 a = wmi_buffer(wil, cpu_to_le32(mem_addr)); 527 528 if (a) 529 seq_printf(s, "[0x%08x] = 0x%08x\n", mem_addr, readl(a)); 530 else 531 seq_printf(s, "[0x%08x] = INVALID\n", mem_addr); 532 533 wil_pm_runtime_put(wil); 534 535 return 0; 536 } 537 538 static int wil_memread_seq_open(struct inode *inode, struct file *file) 539 { 540 return single_open(file, wil_memread_debugfs_show, inode->i_private); 541 } 542 543 static const struct file_operations fops_memread = { 544 .open = wil_memread_seq_open, 545 .release = single_release, 546 .read = seq_read, 547 .llseek = seq_lseek, 548 }; 549 550 static ssize_t wil_read_file_ioblob(struct file *file, char __user *user_buf, 551 size_t count, loff_t *ppos) 552 { 553 enum { max_count = 4096 }; 554 struct wil_blob_wrapper *wil_blob = file->private_data; 555 struct wil6210_priv *wil = wil_blob->wil; 556 loff_t pos = *ppos; 557 size_t available = wil_blob->blob.size; 558 void *buf; 559 size_t ret; 560 int rc; 561 562 if (test_bit(wil_status_suspending, wil_blob->wil->status) || 563 test_bit(wil_status_suspended, wil_blob->wil->status)) 564 return 0; 565 566 if (pos < 0) 567 return -EINVAL; 568 569 if (pos >= available || !count) 570 return 0; 571 572 if (count > available - pos) 573 count = available - pos; 574 if (count > max_count) 575 count = max_count; 576 577 buf = kmalloc(count, GFP_KERNEL); 578 if (!buf) 579 return -ENOMEM; 580 581 rc = wil_pm_runtime_get(wil); 582 if (rc < 0) { 583 kfree(buf); 584 return rc; 585 } 586 587 wil_memcpy_fromio_32(buf, (const void __iomem *) 588 wil_blob->blob.data + pos, count); 589 590 ret = copy_to_user(user_buf, buf, count); 591 592 wil_pm_runtime_put(wil); 593 594 kfree(buf); 595 if (ret == count) 596 return -EFAULT; 597 598 count -= ret; 599 *ppos = pos + count; 600 601 return count; 602 } 603 604 static const struct file_operations fops_ioblob = { 605 .read = wil_read_file_ioblob, 606 .open = simple_open, 607 .llseek = default_llseek, 608 }; 609 610 static 611 struct dentry *wil_debugfs_create_ioblob(const char *name, 612 umode_t mode, 613 struct dentry *parent, 614 struct wil_blob_wrapper *wil_blob) 615 { 616 return debugfs_create_file(name, mode, parent, wil_blob, &fops_ioblob); 617 } 618 619 /*---reset---*/ 620 static ssize_t wil_write_file_reset(struct file *file, const char __user *buf, 621 size_t len, loff_t *ppos) 622 { 623 struct wil6210_priv *wil = file->private_data; 624 struct net_device *ndev = wil_to_ndev(wil); 625 626 /** 627 * BUG: 628 * this code does NOT sync device state with the rest of system 629 * use with care, debug only!!! 630 */ 631 rtnl_lock(); 632 dev_close(ndev); 633 ndev->flags &= ~IFF_UP; 634 rtnl_unlock(); 635 wil_reset(wil, true); 636 637 return len; 638 } 639 640 static const struct file_operations fops_reset = { 641 .write = wil_write_file_reset, 642 .open = simple_open, 643 }; 644 645 /*---write channel 1..4 to rxon for it, 0 to rxoff---*/ 646 static ssize_t wil_write_file_rxon(struct file *file, const char __user *buf, 647 size_t len, loff_t *ppos) 648 { 649 struct wil6210_priv *wil = file->private_data; 650 int rc; 651 long channel; 652 bool on; 653 654 char *kbuf = memdup_user_nul(buf, len); 655 656 if (IS_ERR(kbuf)) 657 return PTR_ERR(kbuf); 658 rc = kstrtol(kbuf, 0, &channel); 659 kfree(kbuf); 660 if (rc) 661 return rc; 662 663 if ((channel < 0) || (channel > 4)) { 664 wil_err(wil, "Invalid channel %ld\n", channel); 665 return -EINVAL; 666 } 667 on = !!channel; 668 669 if (on) { 670 rc = wmi_set_channel(wil, (int)channel); 671 if (rc) 672 return rc; 673 } 674 675 rc = wmi_rxon(wil, on); 676 if (rc) 677 return rc; 678 679 return len; 680 } 681 682 static const struct file_operations fops_rxon = { 683 .write = wil_write_file_rxon, 684 .open = simple_open, 685 }; 686 687 /* block ack control, write: 688 * - "add <ringid> <agg_size> <timeout>" to trigger ADDBA 689 * - "del_tx <ringid> <reason>" to trigger DELBA for Tx side 690 * - "del_rx <CID> <TID> <reason>" to trigger DELBA for Rx side 691 */ 692 static ssize_t wil_write_back(struct file *file, const char __user *buf, 693 size_t len, loff_t *ppos) 694 { 695 struct wil6210_priv *wil = file->private_data; 696 int rc; 697 char *kbuf = kmalloc(len + 1, GFP_KERNEL); 698 char cmd[9]; 699 int p1, p2, p3; 700 701 if (!kbuf) 702 return -ENOMEM; 703 704 rc = simple_write_to_buffer(kbuf, len, ppos, buf, len); 705 if (rc != len) { 706 kfree(kbuf); 707 return rc >= 0 ? -EIO : rc; 708 } 709 710 kbuf[len] = '\0'; 711 rc = sscanf(kbuf, "%8s %d %d %d", cmd, &p1, &p2, &p3); 712 kfree(kbuf); 713 714 if (rc < 0) 715 return rc; 716 if (rc < 2) 717 return -EINVAL; 718 719 if (0 == strcmp(cmd, "add")) { 720 if (rc < 3) { 721 wil_err(wil, "BACK: add require at least 2 params\n"); 722 return -EINVAL; 723 } 724 if (rc < 4) 725 p3 = 0; 726 wmi_addba(wil, p1, p2, p3); 727 } else if (0 == strcmp(cmd, "del_tx")) { 728 if (rc < 3) 729 p2 = WLAN_REASON_QSTA_LEAVE_QBSS; 730 wmi_delba_tx(wil, p1, p2); 731 } else if (0 == strcmp(cmd, "del_rx")) { 732 if (rc < 3) { 733 wil_err(wil, 734 "BACK: del_rx require at least 2 params\n"); 735 return -EINVAL; 736 } 737 if (rc < 4) 738 p3 = WLAN_REASON_QSTA_LEAVE_QBSS; 739 wmi_delba_rx(wil, mk_cidxtid(p1, p2), p3); 740 } else { 741 wil_err(wil, "BACK: Unrecognized command \"%s\"\n", cmd); 742 return -EINVAL; 743 } 744 745 return len; 746 } 747 748 static ssize_t wil_read_back(struct file *file, char __user *user_buf, 749 size_t count, loff_t *ppos) 750 { 751 static const char text[] = "block ack control, write:\n" 752 " - \"add <ringid> <agg_size> <timeout>\" to trigger ADDBA\n" 753 "If missing, <timeout> defaults to 0\n" 754 " - \"del_tx <ringid> <reason>\" to trigger DELBA for Tx side\n" 755 " - \"del_rx <CID> <TID> <reason>\" to trigger DELBA for Rx side\n" 756 "If missing, <reason> set to \"STA_LEAVING\" (36)\n"; 757 758 return simple_read_from_buffer(user_buf, count, ppos, text, 759 sizeof(text)); 760 } 761 762 static const struct file_operations fops_back = { 763 .read = wil_read_back, 764 .write = wil_write_back, 765 .open = simple_open, 766 }; 767 768 /* pmc control, write: 769 * - "alloc <num descriptors> <descriptor_size>" to allocate PMC 770 * - "free" to release memory allocated for PMC 771 */ 772 static ssize_t wil_write_pmccfg(struct file *file, const char __user *buf, 773 size_t len, loff_t *ppos) 774 { 775 struct wil6210_priv *wil = file->private_data; 776 int rc; 777 char *kbuf = kmalloc(len + 1, GFP_KERNEL); 778 char cmd[9]; 779 int num_descs, desc_size; 780 781 if (!kbuf) 782 return -ENOMEM; 783 784 rc = simple_write_to_buffer(kbuf, len, ppos, buf, len); 785 if (rc != len) { 786 kfree(kbuf); 787 return rc >= 0 ? -EIO : rc; 788 } 789 790 kbuf[len] = '\0'; 791 rc = sscanf(kbuf, "%8s %d %d", cmd, &num_descs, &desc_size); 792 kfree(kbuf); 793 794 if (rc < 0) 795 return rc; 796 797 if (rc < 1) { 798 wil_err(wil, "pmccfg: no params given\n"); 799 return -EINVAL; 800 } 801 802 if (0 == strcmp(cmd, "alloc")) { 803 if (rc != 3) { 804 wil_err(wil, "pmccfg: alloc requires 2 params\n"); 805 return -EINVAL; 806 } 807 wil_pmc_alloc(wil, num_descs, desc_size); 808 } else if (0 == strcmp(cmd, "free")) { 809 if (rc != 1) { 810 wil_err(wil, "pmccfg: free does not have any params\n"); 811 return -EINVAL; 812 } 813 wil_pmc_free(wil, true); 814 } else { 815 wil_err(wil, "pmccfg: Unrecognized command \"%s\"\n", cmd); 816 return -EINVAL; 817 } 818 819 return len; 820 } 821 822 static ssize_t wil_read_pmccfg(struct file *file, char __user *user_buf, 823 size_t count, loff_t *ppos) 824 { 825 struct wil6210_priv *wil = file->private_data; 826 char text[256]; 827 char help[] = "pmc control, write:\n" 828 " - \"alloc <num descriptors> <descriptor_size>\" to allocate pmc\n" 829 " - \"free\" to free memory allocated for pmc\n"; 830 831 sprintf(text, "Last command status: %d\n\n%s", 832 wil_pmc_last_cmd_status(wil), 833 help); 834 835 return simple_read_from_buffer(user_buf, count, ppos, text, 836 strlen(text) + 1); 837 } 838 839 static const struct file_operations fops_pmccfg = { 840 .read = wil_read_pmccfg, 841 .write = wil_write_pmccfg, 842 .open = simple_open, 843 }; 844 845 static const struct file_operations fops_pmcdata = { 846 .open = simple_open, 847 .read = wil_pmc_read, 848 .llseek = wil_pmc_llseek, 849 }; 850 851 /*---tx_mgmt---*/ 852 /* Write mgmt frame to this file to send it */ 853 static ssize_t wil_write_file_txmgmt(struct file *file, const char __user *buf, 854 size_t len, loff_t *ppos) 855 { 856 struct wil6210_priv *wil = file->private_data; 857 struct wiphy *wiphy = wil_to_wiphy(wil); 858 struct wireless_dev *wdev = wil_to_wdev(wil); 859 struct cfg80211_mgmt_tx_params params; 860 int rc; 861 void *frame; 862 863 if (!len) 864 return -EINVAL; 865 866 frame = memdup_user(buf, len); 867 if (IS_ERR(frame)) 868 return PTR_ERR(frame); 869 870 params.buf = frame; 871 params.len = len; 872 873 rc = wil_cfg80211_mgmt_tx(wiphy, wdev, ¶ms, NULL); 874 875 kfree(frame); 876 wil_info(wil, "-> %d\n", rc); 877 878 return len; 879 } 880 881 static const struct file_operations fops_txmgmt = { 882 .write = wil_write_file_txmgmt, 883 .open = simple_open, 884 }; 885 886 /* Write WMI command (w/o mbox header) to this file to send it 887 * WMI starts from wil6210_mbox_hdr_wmi header 888 */ 889 static ssize_t wil_write_file_wmi(struct file *file, const char __user *buf, 890 size_t len, loff_t *ppos) 891 { 892 struct wil6210_priv *wil = file->private_data; 893 struct wmi_cmd_hdr *wmi; 894 void *cmd; 895 int cmdlen = len - sizeof(struct wmi_cmd_hdr); 896 u16 cmdid; 897 int rc, rc1; 898 899 if (cmdlen < 0) 900 return -EINVAL; 901 902 wmi = kmalloc(len, GFP_KERNEL); 903 if (!wmi) 904 return -ENOMEM; 905 906 rc = simple_write_to_buffer(wmi, len, ppos, buf, len); 907 if (rc < 0) { 908 kfree(wmi); 909 return rc; 910 } 911 912 cmd = (cmdlen > 0) ? &wmi[1] : NULL; 913 cmdid = le16_to_cpu(wmi->command_id); 914 915 rc1 = wmi_send(wil, cmdid, cmd, cmdlen); 916 kfree(wmi); 917 918 wil_info(wil, "0x%04x[%d] -> %d\n", cmdid, cmdlen, rc1); 919 920 return rc; 921 } 922 923 static const struct file_operations fops_wmi = { 924 .write = wil_write_file_wmi, 925 .open = simple_open, 926 }; 927 928 static void wil_seq_print_skb(struct seq_file *s, struct sk_buff *skb) 929 { 930 int i = 0; 931 int len = skb_headlen(skb); 932 void *p = skb->data; 933 int nr_frags = skb_shinfo(skb)->nr_frags; 934 935 seq_printf(s, " len = %d\n", len); 936 wil_seq_hexdump(s, p, len, " : "); 937 938 if (nr_frags) { 939 seq_printf(s, " nr_frags = %d\n", nr_frags); 940 for (i = 0; i < nr_frags; i++) { 941 const struct skb_frag_struct *frag = 942 &skb_shinfo(skb)->frags[i]; 943 944 len = skb_frag_size(frag); 945 p = skb_frag_address_safe(frag); 946 seq_printf(s, " [%2d] : len = %d\n", i, len); 947 wil_seq_hexdump(s, p, len, " : "); 948 } 949 } 950 } 951 952 /*---------Tx/Rx descriptor------------*/ 953 static int wil_txdesc_debugfs_show(struct seq_file *s, void *data) 954 { 955 struct wil6210_priv *wil = s->private; 956 struct vring *vring; 957 bool tx = (dbg_vring_index < WIL6210_MAX_TX_RINGS); 958 959 vring = tx ? &wil->vring_tx[dbg_vring_index] : &wil->vring_rx; 960 961 if (!vring->va) { 962 if (tx) 963 seq_printf(s, "No Tx[%2d] VRING\n", dbg_vring_index); 964 else 965 seq_puts(s, "No Rx VRING\n"); 966 return 0; 967 } 968 969 if (dbg_txdesc_index < vring->size) { 970 /* use struct vring_tx_desc for Rx as well, 971 * only field used, .dma.length, is the same 972 */ 973 volatile struct vring_tx_desc *d = 974 &vring->va[dbg_txdesc_index].tx; 975 volatile u32 *u = (volatile u32 *)d; 976 struct sk_buff *skb = vring->ctx[dbg_txdesc_index].skb; 977 978 if (tx) 979 seq_printf(s, "Tx[%2d][%3d] = {\n", dbg_vring_index, 980 dbg_txdesc_index); 981 else 982 seq_printf(s, "Rx[%3d] = {\n", dbg_txdesc_index); 983 seq_printf(s, " MAC = 0x%08x 0x%08x 0x%08x 0x%08x\n", 984 u[0], u[1], u[2], u[3]); 985 seq_printf(s, " DMA = 0x%08x 0x%08x 0x%08x 0x%08x\n", 986 u[4], u[5], u[6], u[7]); 987 seq_printf(s, " SKB = 0x%p\n", skb); 988 989 if (skb) { 990 skb_get(skb); 991 wil_seq_print_skb(s, skb); 992 kfree_skb(skb); 993 } 994 seq_puts(s, "}\n"); 995 } else { 996 if (tx) 997 seq_printf(s, "[%2d] TxDesc index (%d) >= size (%d)\n", 998 dbg_vring_index, dbg_txdesc_index, 999 vring->size); 1000 else 1001 seq_printf(s, "RxDesc index (%d) >= size (%d)\n", 1002 dbg_txdesc_index, vring->size); 1003 } 1004 1005 return 0; 1006 } 1007 1008 static int wil_txdesc_seq_open(struct inode *inode, struct file *file) 1009 { 1010 return single_open(file, wil_txdesc_debugfs_show, inode->i_private); 1011 } 1012 1013 static const struct file_operations fops_txdesc = { 1014 .open = wil_txdesc_seq_open, 1015 .release = single_release, 1016 .read = seq_read, 1017 .llseek = seq_lseek, 1018 }; 1019 1020 /*---------beamforming------------*/ 1021 static char *wil_bfstatus_str(u32 status) 1022 { 1023 switch (status) { 1024 case 0: 1025 return "Failed"; 1026 case 1: 1027 return "OK"; 1028 case 2: 1029 return "Retrying"; 1030 default: 1031 return "??"; 1032 } 1033 } 1034 1035 static bool is_all_zeros(void * const x_, size_t sz) 1036 { 1037 /* if reply is all-0, ignore this CID */ 1038 u32 *x = x_; 1039 int n; 1040 1041 for (n = 0; n < sz / sizeof(*x); n++) 1042 if (x[n]) 1043 return false; 1044 1045 return true; 1046 } 1047 1048 static int wil_bf_debugfs_show(struct seq_file *s, void *data) 1049 { 1050 int rc; 1051 int i; 1052 struct wil6210_priv *wil = s->private; 1053 struct wmi_notify_req_cmd cmd = { 1054 .interval_usec = 0, 1055 }; 1056 struct { 1057 struct wmi_cmd_hdr wmi; 1058 struct wmi_notify_req_done_event evt; 1059 } __packed reply; 1060 1061 for (i = 0; i < ARRAY_SIZE(wil->sta); i++) { 1062 u32 status; 1063 1064 cmd.cid = i; 1065 rc = wmi_call(wil, WMI_NOTIFY_REQ_CMDID, &cmd, sizeof(cmd), 1066 WMI_NOTIFY_REQ_DONE_EVENTID, &reply, 1067 sizeof(reply), 20); 1068 /* if reply is all-0, ignore this CID */ 1069 if (rc || is_all_zeros(&reply.evt, sizeof(reply.evt))) 1070 continue; 1071 1072 status = le32_to_cpu(reply.evt.status); 1073 seq_printf(s, "CID %d {\n" 1074 " TSF = 0x%016llx\n" 1075 " TxMCS = %2d TxTpt = %4d\n" 1076 " SQI = %4d\n" 1077 " RSSI = %4d\n" 1078 " Status = 0x%08x %s\n" 1079 " Sectors(rx:tx) my %2d:%2d peer %2d:%2d\n" 1080 " Goodput(rx:tx) %4d:%4d\n" 1081 "}\n", 1082 i, 1083 le64_to_cpu(reply.evt.tsf), 1084 le16_to_cpu(reply.evt.bf_mcs), 1085 le32_to_cpu(reply.evt.tx_tpt), 1086 reply.evt.sqi, 1087 reply.evt.rssi, 1088 status, wil_bfstatus_str(status), 1089 le16_to_cpu(reply.evt.my_rx_sector), 1090 le16_to_cpu(reply.evt.my_tx_sector), 1091 le16_to_cpu(reply.evt.other_rx_sector), 1092 le16_to_cpu(reply.evt.other_tx_sector), 1093 le32_to_cpu(reply.evt.rx_goodput), 1094 le32_to_cpu(reply.evt.tx_goodput)); 1095 } 1096 return 0; 1097 } 1098 1099 static int wil_bf_seq_open(struct inode *inode, struct file *file) 1100 { 1101 return single_open(file, wil_bf_debugfs_show, inode->i_private); 1102 } 1103 1104 static const struct file_operations fops_bf = { 1105 .open = wil_bf_seq_open, 1106 .release = single_release, 1107 .read = seq_read, 1108 .llseek = seq_lseek, 1109 }; 1110 1111 /*---------temp------------*/ 1112 static void print_temp(struct seq_file *s, const char *prefix, u32 t) 1113 { 1114 switch (t) { 1115 case 0: 1116 case ~(u32)0: 1117 seq_printf(s, "%s N/A\n", prefix); 1118 break; 1119 default: 1120 seq_printf(s, "%s %d.%03d\n", prefix, t / 1000, t % 1000); 1121 break; 1122 } 1123 } 1124 1125 static int wil_temp_debugfs_show(struct seq_file *s, void *data) 1126 { 1127 struct wil6210_priv *wil = s->private; 1128 u32 t_m, t_r; 1129 int rc = wmi_get_temperature(wil, &t_m, &t_r); 1130 1131 if (rc) { 1132 seq_puts(s, "Failed\n"); 1133 return 0; 1134 } 1135 1136 print_temp(s, "T_mac =", t_m); 1137 print_temp(s, "T_radio =", t_r); 1138 1139 return 0; 1140 } 1141 1142 static int wil_temp_seq_open(struct inode *inode, struct file *file) 1143 { 1144 return single_open(file, wil_temp_debugfs_show, inode->i_private); 1145 } 1146 1147 static const struct file_operations fops_temp = { 1148 .open = wil_temp_seq_open, 1149 .release = single_release, 1150 .read = seq_read, 1151 .llseek = seq_lseek, 1152 }; 1153 1154 /*---------freq------------*/ 1155 static int wil_freq_debugfs_show(struct seq_file *s, void *data) 1156 { 1157 struct wil6210_priv *wil = s->private; 1158 struct wireless_dev *wdev = wil_to_wdev(wil); 1159 u16 freq = wdev->chandef.chan ? wdev->chandef.chan->center_freq : 0; 1160 1161 seq_printf(s, "Freq = %d\n", freq); 1162 1163 return 0; 1164 } 1165 1166 static int wil_freq_seq_open(struct inode *inode, struct file *file) 1167 { 1168 return single_open(file, wil_freq_debugfs_show, inode->i_private); 1169 } 1170 1171 static const struct file_operations fops_freq = { 1172 .open = wil_freq_seq_open, 1173 .release = single_release, 1174 .read = seq_read, 1175 .llseek = seq_lseek, 1176 }; 1177 1178 /*---------link------------*/ 1179 static int wil_link_debugfs_show(struct seq_file *s, void *data) 1180 { 1181 struct wil6210_priv *wil = s->private; 1182 struct station_info sinfo; 1183 int i, rc; 1184 1185 for (i = 0; i < ARRAY_SIZE(wil->sta); i++) { 1186 struct wil_sta_info *p = &wil->sta[i]; 1187 char *status = "unknown"; 1188 1189 switch (p->status) { 1190 case wil_sta_unused: 1191 status = "unused "; 1192 break; 1193 case wil_sta_conn_pending: 1194 status = "pending "; 1195 break; 1196 case wil_sta_connected: 1197 status = "connected"; 1198 break; 1199 } 1200 seq_printf(s, "[%d] %pM %s\n", i, p->addr, status); 1201 1202 if (p->status == wil_sta_connected) { 1203 rc = wil_cid_fill_sinfo(wil, i, &sinfo); 1204 if (rc) 1205 return rc; 1206 1207 seq_printf(s, " Tx_mcs = %d\n", sinfo.txrate.mcs); 1208 seq_printf(s, " Rx_mcs = %d\n", sinfo.rxrate.mcs); 1209 seq_printf(s, " SQ = %d\n", sinfo.signal); 1210 } 1211 } 1212 1213 return 0; 1214 } 1215 1216 static int wil_link_seq_open(struct inode *inode, struct file *file) 1217 { 1218 return single_open(file, wil_link_debugfs_show, inode->i_private); 1219 } 1220 1221 static const struct file_operations fops_link = { 1222 .open = wil_link_seq_open, 1223 .release = single_release, 1224 .read = seq_read, 1225 .llseek = seq_lseek, 1226 }; 1227 1228 /*---------info------------*/ 1229 static int wil_info_debugfs_show(struct seq_file *s, void *data) 1230 { 1231 struct wil6210_priv *wil = s->private; 1232 struct net_device *ndev = wil_to_ndev(wil); 1233 int is_ac = power_supply_is_system_supplied(); 1234 int rx = atomic_xchg(&wil->isr_count_rx, 0); 1235 int tx = atomic_xchg(&wil->isr_count_tx, 0); 1236 static ulong rxf_old, txf_old; 1237 ulong rxf = ndev->stats.rx_packets; 1238 ulong txf = ndev->stats.tx_packets; 1239 unsigned int i; 1240 1241 /* >0 : AC; 0 : battery; <0 : error */ 1242 seq_printf(s, "AC powered : %d\n", is_ac); 1243 seq_printf(s, "Rx irqs:packets : %8d : %8ld\n", rx, rxf - rxf_old); 1244 seq_printf(s, "Tx irqs:packets : %8d : %8ld\n", tx, txf - txf_old); 1245 rxf_old = rxf; 1246 txf_old = txf; 1247 1248 #define CHECK_QSTATE(x) (state & BIT(__QUEUE_STATE_ ## x)) ? \ 1249 " " __stringify(x) : "" 1250 1251 for (i = 0; i < ndev->num_tx_queues; i++) { 1252 struct netdev_queue *txq = netdev_get_tx_queue(ndev, i); 1253 unsigned long state = txq->state; 1254 1255 seq_printf(s, "Tx queue[%i] state : 0x%lx%s%s%s\n", i, state, 1256 CHECK_QSTATE(DRV_XOFF), 1257 CHECK_QSTATE(STACK_XOFF), 1258 CHECK_QSTATE(FROZEN) 1259 ); 1260 } 1261 #undef CHECK_QSTATE 1262 return 0; 1263 } 1264 1265 static int wil_info_seq_open(struct inode *inode, struct file *file) 1266 { 1267 return single_open(file, wil_info_debugfs_show, inode->i_private); 1268 } 1269 1270 static const struct file_operations fops_info = { 1271 .open = wil_info_seq_open, 1272 .release = single_release, 1273 .read = seq_read, 1274 .llseek = seq_lseek, 1275 }; 1276 1277 /*---------recovery------------*/ 1278 /* mode = [manual|auto] 1279 * state = [idle|pending|running] 1280 */ 1281 static ssize_t wil_read_file_recovery(struct file *file, char __user *user_buf, 1282 size_t count, loff_t *ppos) 1283 { 1284 struct wil6210_priv *wil = file->private_data; 1285 char buf[80]; 1286 int n; 1287 static const char * const sstate[] = {"idle", "pending", "running"}; 1288 1289 n = snprintf(buf, sizeof(buf), "mode = %s\nstate = %s\n", 1290 no_fw_recovery ? "manual" : "auto", 1291 sstate[wil->recovery_state]); 1292 1293 n = min_t(int, n, sizeof(buf)); 1294 1295 return simple_read_from_buffer(user_buf, count, ppos, 1296 buf, n); 1297 } 1298 1299 static ssize_t wil_write_file_recovery(struct file *file, 1300 const char __user *buf_, 1301 size_t count, loff_t *ppos) 1302 { 1303 struct wil6210_priv *wil = file->private_data; 1304 static const char run_command[] = "run"; 1305 char buf[sizeof(run_command) + 1]; /* to detect "runx" */ 1306 ssize_t rc; 1307 1308 if (wil->recovery_state != fw_recovery_pending) { 1309 wil_err(wil, "No recovery pending\n"); 1310 return -EINVAL; 1311 } 1312 1313 if (*ppos != 0) { 1314 wil_err(wil, "Offset [%d]\n", (int)*ppos); 1315 return -EINVAL; 1316 } 1317 1318 if (count > sizeof(buf)) { 1319 wil_err(wil, "Input too long, len = %d\n", (int)count); 1320 return -EINVAL; 1321 } 1322 1323 rc = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, buf_, count); 1324 if (rc < 0) 1325 return rc; 1326 1327 buf[rc] = '\0'; 1328 if (0 == strcmp(buf, run_command)) 1329 wil_set_recovery_state(wil, fw_recovery_running); 1330 else 1331 wil_err(wil, "Bad recovery command \"%s\"\n", buf); 1332 1333 return rc; 1334 } 1335 1336 static const struct file_operations fops_recovery = { 1337 .read = wil_read_file_recovery, 1338 .write = wil_write_file_recovery, 1339 .open = simple_open, 1340 }; 1341 1342 /*---------Station matrix------------*/ 1343 static void wil_print_rxtid(struct seq_file *s, struct wil_tid_ampdu_rx *r) 1344 { 1345 int i; 1346 u16 index = ((r->head_seq_num - r->ssn) & 0xfff) % r->buf_size; 1347 unsigned long long drop_dup = r->drop_dup, drop_old = r->drop_old; 1348 1349 seq_printf(s, "([%2d] %3d TU) 0x%03x [", r->buf_size, r->timeout, 1350 r->head_seq_num); 1351 for (i = 0; i < r->buf_size; i++) { 1352 if (i == index) 1353 seq_printf(s, "%c", r->reorder_buf[i] ? 'O' : '|'); 1354 else 1355 seq_printf(s, "%c", r->reorder_buf[i] ? '*' : '_'); 1356 } 1357 seq_printf(s, 1358 "] total %llu drop %llu (dup %llu + old %llu) last 0x%03x\n", 1359 r->total, drop_dup + drop_old, drop_dup, drop_old, 1360 r->ssn_last_drop); 1361 } 1362 1363 static void wil_print_rxtid_crypto(struct seq_file *s, int tid, 1364 struct wil_tid_crypto_rx *c) 1365 { 1366 int i; 1367 1368 for (i = 0; i < 4; i++) { 1369 struct wil_tid_crypto_rx_single *cc = &c->key_id[i]; 1370 1371 if (cc->key_set) 1372 goto has_keys; 1373 } 1374 return; 1375 1376 has_keys: 1377 if (tid < WIL_STA_TID_NUM) 1378 seq_printf(s, " [%2d] PN", tid); 1379 else 1380 seq_puts(s, " [GR] PN"); 1381 1382 for (i = 0; i < 4; i++) { 1383 struct wil_tid_crypto_rx_single *cc = &c->key_id[i]; 1384 1385 seq_printf(s, " [%i%s]%6phN", i, cc->key_set ? "+" : "-", 1386 cc->pn); 1387 } 1388 seq_puts(s, "\n"); 1389 } 1390 1391 static int wil_sta_debugfs_show(struct seq_file *s, void *data) 1392 __acquires(&p->tid_rx_lock) __releases(&p->tid_rx_lock) 1393 { 1394 struct wil6210_priv *wil = s->private; 1395 int i, tid, mcs; 1396 1397 for (i = 0; i < ARRAY_SIZE(wil->sta); i++) { 1398 struct wil_sta_info *p = &wil->sta[i]; 1399 char *status = "unknown"; 1400 u8 aid = 0; 1401 1402 switch (p->status) { 1403 case wil_sta_unused: 1404 status = "unused "; 1405 break; 1406 case wil_sta_conn_pending: 1407 status = "pending "; 1408 break; 1409 case wil_sta_connected: 1410 status = "connected"; 1411 aid = p->aid; 1412 break; 1413 } 1414 seq_printf(s, "[%d] %pM %s AID %d\n", i, p->addr, status, aid); 1415 1416 if (p->status == wil_sta_connected) { 1417 spin_lock_bh(&p->tid_rx_lock); 1418 for (tid = 0; tid < WIL_STA_TID_NUM; tid++) { 1419 struct wil_tid_ampdu_rx *r = p->tid_rx[tid]; 1420 struct wil_tid_crypto_rx *c = 1421 &p->tid_crypto_rx[tid]; 1422 1423 if (r) { 1424 seq_printf(s, " [%2d] ", tid); 1425 wil_print_rxtid(s, r); 1426 } 1427 1428 wil_print_rxtid_crypto(s, tid, c); 1429 } 1430 wil_print_rxtid_crypto(s, WIL_STA_TID_NUM, 1431 &p->group_crypto_rx); 1432 spin_unlock_bh(&p->tid_rx_lock); 1433 seq_printf(s, 1434 "Rx invalid frame: non-data %lu, short %lu, large %lu, replay %lu\n", 1435 p->stats.rx_non_data_frame, 1436 p->stats.rx_short_frame, 1437 p->stats.rx_large_frame, 1438 p->stats.rx_replay); 1439 1440 seq_puts(s, "Rx/MCS:"); 1441 for (mcs = 0; mcs < ARRAY_SIZE(p->stats.rx_per_mcs); 1442 mcs++) 1443 seq_printf(s, " %lld", 1444 p->stats.rx_per_mcs[mcs]); 1445 seq_puts(s, "\n"); 1446 } 1447 } 1448 1449 return 0; 1450 } 1451 1452 static int wil_sta_seq_open(struct inode *inode, struct file *file) 1453 { 1454 return single_open(file, wil_sta_debugfs_show, inode->i_private); 1455 } 1456 1457 static const struct file_operations fops_sta = { 1458 .open = wil_sta_seq_open, 1459 .release = single_release, 1460 .read = seq_read, 1461 .llseek = seq_lseek, 1462 }; 1463 1464 static ssize_t wil_read_file_led_cfg(struct file *file, char __user *user_buf, 1465 size_t count, loff_t *ppos) 1466 { 1467 char buf[80]; 1468 int n; 1469 1470 n = snprintf(buf, sizeof(buf), 1471 "led_id is set to %d, echo 1 to enable, 0 to disable\n", 1472 led_id); 1473 1474 n = min_t(int, n, sizeof(buf)); 1475 1476 return simple_read_from_buffer(user_buf, count, ppos, 1477 buf, n); 1478 } 1479 1480 static ssize_t wil_write_file_led_cfg(struct file *file, 1481 const char __user *buf_, 1482 size_t count, loff_t *ppos) 1483 { 1484 struct wil6210_priv *wil = file->private_data; 1485 int val; 1486 int rc; 1487 1488 rc = kstrtoint_from_user(buf_, count, 0, &val); 1489 if (rc) { 1490 wil_err(wil, "Invalid argument\n"); 1491 return rc; 1492 } 1493 1494 wil_info(wil, "%s led %d\n", val ? "Enabling" : "Disabling", led_id); 1495 rc = wmi_led_cfg(wil, val); 1496 if (rc) { 1497 wil_info(wil, "%s led %d failed\n", 1498 val ? "Enabling" : "Disabling", led_id); 1499 return rc; 1500 } 1501 1502 return count; 1503 } 1504 1505 static const struct file_operations fops_led_cfg = { 1506 .read = wil_read_file_led_cfg, 1507 .write = wil_write_file_led_cfg, 1508 .open = simple_open, 1509 }; 1510 1511 /* led_blink_time, write: 1512 * "<blink_on_slow> <blink_off_slow> <blink_on_med> <blink_off_med> <blink_on_fast> <blink_off_fast> 1513 */ 1514 static ssize_t wil_write_led_blink_time(struct file *file, 1515 const char __user *buf, 1516 size_t len, loff_t *ppos) 1517 { 1518 int rc; 1519 char *kbuf = kmalloc(len + 1, GFP_KERNEL); 1520 1521 if (!kbuf) 1522 return -ENOMEM; 1523 1524 rc = simple_write_to_buffer(kbuf, len, ppos, buf, len); 1525 if (rc != len) { 1526 kfree(kbuf); 1527 return rc >= 0 ? -EIO : rc; 1528 } 1529 1530 kbuf[len] = '\0'; 1531 rc = sscanf(kbuf, "%d %d %d %d %d %d", 1532 &led_blink_time[WIL_LED_TIME_SLOW].on_ms, 1533 &led_blink_time[WIL_LED_TIME_SLOW].off_ms, 1534 &led_blink_time[WIL_LED_TIME_MED].on_ms, 1535 &led_blink_time[WIL_LED_TIME_MED].off_ms, 1536 &led_blink_time[WIL_LED_TIME_FAST].on_ms, 1537 &led_blink_time[WIL_LED_TIME_FAST].off_ms); 1538 kfree(kbuf); 1539 1540 if (rc < 0) 1541 return rc; 1542 if (rc < 6) 1543 return -EINVAL; 1544 1545 return len; 1546 } 1547 1548 static ssize_t wil_read_led_blink_time(struct file *file, char __user *user_buf, 1549 size_t count, loff_t *ppos) 1550 { 1551 static char text[400]; 1552 1553 snprintf(text, sizeof(text), 1554 "To set led blink on/off time variables write:\n" 1555 "<blink_on_slow> <blink_off_slow> <blink_on_med> " 1556 "<blink_off_med> <blink_on_fast> <blink_off_fast>\n" 1557 "The current values are:\n" 1558 "%d %d %d %d %d %d\n", 1559 led_blink_time[WIL_LED_TIME_SLOW].on_ms, 1560 led_blink_time[WIL_LED_TIME_SLOW].off_ms, 1561 led_blink_time[WIL_LED_TIME_MED].on_ms, 1562 led_blink_time[WIL_LED_TIME_MED].off_ms, 1563 led_blink_time[WIL_LED_TIME_FAST].on_ms, 1564 led_blink_time[WIL_LED_TIME_FAST].off_ms); 1565 1566 return simple_read_from_buffer(user_buf, count, ppos, text, 1567 sizeof(text)); 1568 } 1569 1570 static const struct file_operations fops_led_blink_time = { 1571 .read = wil_read_led_blink_time, 1572 .write = wil_write_led_blink_time, 1573 .open = simple_open, 1574 }; 1575 1576 /*---------FW capabilities------------*/ 1577 static int wil_fw_capabilities_debugfs_show(struct seq_file *s, void *data) 1578 { 1579 struct wil6210_priv *wil = s->private; 1580 1581 seq_printf(s, "fw_capabilities : %*pb\n", WMI_FW_CAPABILITY_MAX, 1582 wil->fw_capabilities); 1583 1584 return 0; 1585 } 1586 1587 static int wil_fw_capabilities_seq_open(struct inode *inode, struct file *file) 1588 { 1589 return single_open(file, wil_fw_capabilities_debugfs_show, 1590 inode->i_private); 1591 } 1592 1593 static const struct file_operations fops_fw_capabilities = { 1594 .open = wil_fw_capabilities_seq_open, 1595 .release = single_release, 1596 .read = seq_read, 1597 .llseek = seq_lseek, 1598 }; 1599 1600 /*---------FW version------------*/ 1601 static int wil_fw_version_debugfs_show(struct seq_file *s, void *data) 1602 { 1603 struct wil6210_priv *wil = s->private; 1604 1605 if (wil->fw_version[0]) 1606 seq_printf(s, "%s\n", wil->fw_version); 1607 else 1608 seq_puts(s, "N/A\n"); 1609 1610 return 0; 1611 } 1612 1613 static int wil_fw_version_seq_open(struct inode *inode, struct file *file) 1614 { 1615 return single_open(file, wil_fw_version_debugfs_show, 1616 inode->i_private); 1617 } 1618 1619 static const struct file_operations fops_fw_version = { 1620 .open = wil_fw_version_seq_open, 1621 .release = single_release, 1622 .read = seq_read, 1623 .llseek = seq_lseek, 1624 }; 1625 1626 /*---------suspend_stats---------*/ 1627 static ssize_t wil_write_suspend_stats(struct file *file, 1628 const char __user *buf, 1629 size_t len, loff_t *ppos) 1630 { 1631 struct wil6210_priv *wil = file->private_data; 1632 1633 memset(&wil->suspend_stats, 0, sizeof(wil->suspend_stats)); 1634 1635 return len; 1636 } 1637 1638 static ssize_t wil_read_suspend_stats(struct file *file, 1639 char __user *user_buf, 1640 size_t count, loff_t *ppos) 1641 { 1642 struct wil6210_priv *wil = file->private_data; 1643 char *text; 1644 int n, ret, text_size = 500; 1645 1646 text = kmalloc(text_size, GFP_KERNEL); 1647 if (!text) 1648 return -ENOMEM; 1649 1650 n = snprintf(text, text_size, 1651 "Radio on suspend statistics:\n" 1652 "successful suspends:%ld failed suspends:%ld\n" 1653 "successful resumes:%ld failed resumes:%ld\n" 1654 "rejected by device:%ld\n" 1655 "Radio off suspend statistics:\n" 1656 "successful suspends:%ld failed suspends:%ld\n" 1657 "successful resumes:%ld failed resumes:%ld\n" 1658 "General statistics:\n" 1659 "rejected by host:%ld\n", 1660 wil->suspend_stats.r_on.successful_suspends, 1661 wil->suspend_stats.r_on.failed_suspends, 1662 wil->suspend_stats.r_on.successful_resumes, 1663 wil->suspend_stats.r_on.failed_resumes, 1664 wil->suspend_stats.rejected_by_device, 1665 wil->suspend_stats.r_off.successful_suspends, 1666 wil->suspend_stats.r_off.failed_suspends, 1667 wil->suspend_stats.r_off.successful_resumes, 1668 wil->suspend_stats.r_off.failed_resumes, 1669 wil->suspend_stats.rejected_by_host); 1670 1671 n = min_t(int, n, text_size); 1672 1673 ret = simple_read_from_buffer(user_buf, count, ppos, text, n); 1674 1675 kfree(text); 1676 1677 return ret; 1678 } 1679 1680 static const struct file_operations fops_suspend_stats = { 1681 .read = wil_read_suspend_stats, 1682 .write = wil_write_suspend_stats, 1683 .open = simple_open, 1684 }; 1685 1686 /*----------------*/ 1687 static void wil6210_debugfs_init_blobs(struct wil6210_priv *wil, 1688 struct dentry *dbg) 1689 { 1690 int i; 1691 char name[32]; 1692 1693 for (i = 0; i < ARRAY_SIZE(fw_mapping); i++) { 1694 struct wil_blob_wrapper *wil_blob = &wil->blobs[i]; 1695 struct debugfs_blob_wrapper *blob = &wil_blob->blob; 1696 const struct fw_map *map = &fw_mapping[i]; 1697 1698 if (!map->name) 1699 continue; 1700 1701 wil_blob->wil = wil; 1702 blob->data = (void * __force)wil->csr + HOSTADDR(map->host); 1703 blob->size = map->to - map->from; 1704 snprintf(name, sizeof(name), "blob_%s", map->name); 1705 wil_debugfs_create_ioblob(name, 0444, dbg, wil_blob); 1706 } 1707 } 1708 1709 /* misc files */ 1710 static const struct { 1711 const char *name; 1712 umode_t mode; 1713 const struct file_operations *fops; 1714 } dbg_files[] = { 1715 {"mbox", 0444, &fops_mbox}, 1716 {"vrings", 0444, &fops_vring}, 1717 {"stations", 0444, &fops_sta}, 1718 {"desc", 0444, &fops_txdesc}, 1719 {"bf", 0444, &fops_bf}, 1720 {"mem_val", 0644, &fops_memread}, 1721 {"reset", 0244, &fops_reset}, 1722 {"rxon", 0244, &fops_rxon}, 1723 {"tx_mgmt", 0244, &fops_txmgmt}, 1724 {"wmi_send", 0244, &fops_wmi}, 1725 {"back", 0644, &fops_back}, 1726 {"pmccfg", 0644, &fops_pmccfg}, 1727 {"pmcdata", 0444, &fops_pmcdata}, 1728 {"temp", 0444, &fops_temp}, 1729 {"freq", 0444, &fops_freq}, 1730 {"link", 0444, &fops_link}, 1731 {"info", 0444, &fops_info}, 1732 {"recovery", 0644, &fops_recovery}, 1733 {"led_cfg", 0644, &fops_led_cfg}, 1734 {"led_blink_time", 0644, &fops_led_blink_time}, 1735 {"fw_capabilities", 0444, &fops_fw_capabilities}, 1736 {"fw_version", 0444, &fops_fw_version}, 1737 {"suspend_stats", 0644, &fops_suspend_stats}, 1738 }; 1739 1740 static void wil6210_debugfs_init_files(struct wil6210_priv *wil, 1741 struct dentry *dbg) 1742 { 1743 int i; 1744 1745 for (i = 0; i < ARRAY_SIZE(dbg_files); i++) 1746 debugfs_create_file(dbg_files[i].name, dbg_files[i].mode, dbg, 1747 wil, dbg_files[i].fops); 1748 } 1749 1750 /* interrupt control blocks */ 1751 static const struct { 1752 const char *name; 1753 u32 icr_off; 1754 } dbg_icr[] = { 1755 {"USER_ICR", HOSTADDR(RGF_USER_USER_ICR)}, 1756 {"DMA_EP_TX_ICR", HOSTADDR(RGF_DMA_EP_TX_ICR)}, 1757 {"DMA_EP_RX_ICR", HOSTADDR(RGF_DMA_EP_RX_ICR)}, 1758 {"DMA_EP_MISC_ICR", HOSTADDR(RGF_DMA_EP_MISC_ICR)}, 1759 }; 1760 1761 static void wil6210_debugfs_init_isr(struct wil6210_priv *wil, 1762 struct dentry *dbg) 1763 { 1764 int i; 1765 1766 for (i = 0; i < ARRAY_SIZE(dbg_icr); i++) 1767 wil6210_debugfs_create_ISR(wil, dbg_icr[i].name, dbg, 1768 dbg_icr[i].icr_off); 1769 } 1770 1771 #define WIL_FIELD(name, mode, type) { __stringify(name), mode, \ 1772 offsetof(struct wil6210_priv, name), type} 1773 1774 /* fields in struct wil6210_priv */ 1775 static const struct dbg_off dbg_wil_off[] = { 1776 WIL_FIELD(privacy, 0444, doff_u32), 1777 WIL_FIELD(status[0], 0644, doff_ulong), 1778 WIL_FIELD(hw_version, 0444, doff_x32), 1779 WIL_FIELD(recovery_count, 0444, doff_u32), 1780 WIL_FIELD(ap_isolate, 0444, doff_u32), 1781 WIL_FIELD(discovery_mode, 0644, doff_u8), 1782 WIL_FIELD(chip_revision, 0444, doff_u8), 1783 WIL_FIELD(abft_len, 0644, doff_u8), 1784 WIL_FIELD(wakeup_trigger, 0644, doff_u8), 1785 WIL_FIELD(vring_idle_trsh, 0644, doff_u32), 1786 {}, 1787 }; 1788 1789 static const struct dbg_off dbg_wil_regs[] = { 1790 {"RGF_MAC_MTRL_COUNTER_0", 0444, HOSTADDR(RGF_MAC_MTRL_COUNTER_0), 1791 doff_io32}, 1792 {"RGF_USER_USAGE_1", 0444, HOSTADDR(RGF_USER_USAGE_1), doff_io32}, 1793 {}, 1794 }; 1795 1796 /* static parameters */ 1797 static const struct dbg_off dbg_statics[] = { 1798 {"desc_index", 0644, (ulong)&dbg_txdesc_index, doff_u32}, 1799 {"vring_index", 0644, (ulong)&dbg_vring_index, doff_u32}, 1800 {"mem_addr", 0644, (ulong)&mem_addr, doff_u32}, 1801 {"led_polarity", 0644, (ulong)&led_polarity, doff_u8}, 1802 {}, 1803 }; 1804 1805 static const int dbg_off_count = 4 * (ARRAY_SIZE(isr_off) - 1) + 1806 ARRAY_SIZE(dbg_wil_regs) - 1 + 1807 ARRAY_SIZE(pseudo_isr_off) - 1 + 1808 ARRAY_SIZE(lgc_itr_cnt_off) - 1 + 1809 ARRAY_SIZE(tx_itr_cnt_off) - 1 + 1810 ARRAY_SIZE(rx_itr_cnt_off) - 1; 1811 1812 int wil6210_debugfs_init(struct wil6210_priv *wil) 1813 { 1814 struct dentry *dbg = wil->debug = debugfs_create_dir(WIL_NAME, 1815 wil_to_wiphy(wil)->debugfsdir); 1816 if (IS_ERR_OR_NULL(dbg)) 1817 return -ENODEV; 1818 1819 wil->dbg_data.data_arr = kcalloc(dbg_off_count, 1820 sizeof(struct wil_debugfs_iomem_data), 1821 GFP_KERNEL); 1822 if (!wil->dbg_data.data_arr) { 1823 debugfs_remove_recursive(dbg); 1824 wil->debug = NULL; 1825 return -ENOMEM; 1826 } 1827 1828 wil->dbg_data.iomem_data_count = 0; 1829 1830 wil_pmc_init(wil); 1831 1832 wil6210_debugfs_init_files(wil, dbg); 1833 wil6210_debugfs_init_isr(wil, dbg); 1834 wil6210_debugfs_init_blobs(wil, dbg); 1835 wil6210_debugfs_init_offset(wil, dbg, wil, dbg_wil_off); 1836 wil6210_debugfs_init_offset(wil, dbg, (void * __force)wil->csr, 1837 dbg_wil_regs); 1838 wil6210_debugfs_init_offset(wil, dbg, NULL, dbg_statics); 1839 1840 wil6210_debugfs_create_pseudo_ISR(wil, dbg); 1841 1842 wil6210_debugfs_create_ITR_CNT(wil, dbg); 1843 1844 return 0; 1845 } 1846 1847 void wil6210_debugfs_remove(struct wil6210_priv *wil) 1848 { 1849 debugfs_remove_recursive(wil->debug); 1850 wil->debug = NULL; 1851 1852 kfree(wil->dbg_data.data_arr); 1853 1854 /* free pmc memory without sending command to fw, as it will 1855 * be reset on the way down anyway 1856 */ 1857 wil_pmc_free(wil, false); 1858 } 1859