1// SPDX-License-Identifier: GPL-2.0-only 2/****************************************************************************** 3 * 4 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. 5 * 6 * Contact Information: 7 * Intel Linux Wireless <ilw@linux.intel.com> 8 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 9 *****************************************************************************/ 10#include <linux/ieee80211.h> 11#include <linux/export.h> 12#include <net/mac80211.h> 13 14#include "common.h" 15 16static void 17il_clear_traffic_stats(struct il_priv *il) 18{ 19 memset(&il->tx_stats, 0, sizeof(struct traffic_stats)); 20 memset(&il->rx_stats, 0, sizeof(struct traffic_stats)); 21} 22 23/* 24 * il_update_stats function record all the MGMT, CTRL and DATA pkt for 25 * both TX and Rx . Use debugfs to display the rx/rx_stats 26 */ 27void 28il_update_stats(struct il_priv *il, bool is_tx, __le16 fc, u16 len) 29{ 30 struct traffic_stats *stats; 31 32 if (is_tx) 33 stats = &il->tx_stats; 34 else 35 stats = &il->rx_stats; 36 37 if (ieee80211_is_mgmt(fc)) { 38 switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) { 39 case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ): 40 stats->mgmt[MANAGEMENT_ASSOC_REQ]++; 41 break; 42 case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP): 43 stats->mgmt[MANAGEMENT_ASSOC_RESP]++; 44 break; 45 case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ): 46 stats->mgmt[MANAGEMENT_REASSOC_REQ]++; 47 break; 48 case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP): 49 stats->mgmt[MANAGEMENT_REASSOC_RESP]++; 50 break; 51 case cpu_to_le16(IEEE80211_STYPE_PROBE_REQ): 52 stats->mgmt[MANAGEMENT_PROBE_REQ]++; 53 break; 54 case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP): 55 stats->mgmt[MANAGEMENT_PROBE_RESP]++; 56 break; 57 case cpu_to_le16(IEEE80211_STYPE_BEACON): 58 stats->mgmt[MANAGEMENT_BEACON]++; 59 break; 60 case cpu_to_le16(IEEE80211_STYPE_ATIM): 61 stats->mgmt[MANAGEMENT_ATIM]++; 62 break; 63 case cpu_to_le16(IEEE80211_STYPE_DISASSOC): 64 stats->mgmt[MANAGEMENT_DISASSOC]++; 65 break; 66 case cpu_to_le16(IEEE80211_STYPE_AUTH): 67 stats->mgmt[MANAGEMENT_AUTH]++; 68 break; 69 case cpu_to_le16(IEEE80211_STYPE_DEAUTH): 70 stats->mgmt[MANAGEMENT_DEAUTH]++; 71 break; 72 case cpu_to_le16(IEEE80211_STYPE_ACTION): 73 stats->mgmt[MANAGEMENT_ACTION]++; 74 break; 75 } 76 } else if (ieee80211_is_ctl(fc)) { 77 switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) { 78 case cpu_to_le16(IEEE80211_STYPE_BACK_REQ): 79 stats->ctrl[CONTROL_BACK_REQ]++; 80 break; 81 case cpu_to_le16(IEEE80211_STYPE_BACK): 82 stats->ctrl[CONTROL_BACK]++; 83 break; 84 case cpu_to_le16(IEEE80211_STYPE_PSPOLL): 85 stats->ctrl[CONTROL_PSPOLL]++; 86 break; 87 case cpu_to_le16(IEEE80211_STYPE_RTS): 88 stats->ctrl[CONTROL_RTS]++; 89 break; 90 case cpu_to_le16(IEEE80211_STYPE_CTS): 91 stats->ctrl[CONTROL_CTS]++; 92 break; 93 case cpu_to_le16(IEEE80211_STYPE_ACK): 94 stats->ctrl[CONTROL_ACK]++; 95 break; 96 case cpu_to_le16(IEEE80211_STYPE_CFEND): 97 stats->ctrl[CONTROL_CFEND]++; 98 break; 99 case cpu_to_le16(IEEE80211_STYPE_CFENDACK): 100 stats->ctrl[CONTROL_CFENDACK]++; 101 break; 102 } 103 } else { 104 /* data */ 105 stats->data_cnt++; 106 stats->data_bytes += len; 107 } 108} 109EXPORT_SYMBOL(il_update_stats); 110 111/* create and remove of files */ 112#define DEBUGFS_ADD_FILE(name, parent, mode) do { \ 113 debugfs_create_file(#name, mode, parent, il, \ 114 &il_dbgfs_##name##_ops); \ 115} while (0) 116 117#define DEBUGFS_ADD_BOOL(name, parent, ptr) do { \ 118 debugfs_create_bool(#name, 0600, parent, ptr); \ 119} while (0) 120 121/* file operation */ 122#define DEBUGFS_READ_FUNC(name) \ 123static ssize_t il_dbgfs_##name##_read(struct file *file, \ 124 char __user *user_buf, \ 125 size_t count, loff_t *ppos); 126 127#define DEBUGFS_WRITE_FUNC(name) \ 128static ssize_t il_dbgfs_##name##_write(struct file *file, \ 129 const char __user *user_buf, \ 130 size_t count, loff_t *ppos); 131 132 133#define DEBUGFS_READ_FILE_OPS(name) \ 134 DEBUGFS_READ_FUNC(name); \ 135static const struct file_operations il_dbgfs_##name##_ops = { \ 136 .read = il_dbgfs_##name##_read, \ 137 .open = simple_open, \ 138 .llseek = generic_file_llseek, \ 139}; 140 141#define DEBUGFS_WRITE_FILE_OPS(name) \ 142 DEBUGFS_WRITE_FUNC(name); \ 143static const struct file_operations il_dbgfs_##name##_ops = { \ 144 .write = il_dbgfs_##name##_write, \ 145 .open = simple_open, \ 146 .llseek = generic_file_llseek, \ 147}; 148 149#define DEBUGFS_READ_WRITE_FILE_OPS(name) \ 150 DEBUGFS_READ_FUNC(name); \ 151 DEBUGFS_WRITE_FUNC(name); \ 152static const struct file_operations il_dbgfs_##name##_ops = { \ 153 .write = il_dbgfs_##name##_write, \ 154 .read = il_dbgfs_##name##_read, \ 155 .open = simple_open, \ 156 .llseek = generic_file_llseek, \ 157}; 158 159static const char * 160il_get_mgmt_string(int cmd) 161{ 162 switch (cmd) { 163 IL_CMD(MANAGEMENT_ASSOC_REQ); 164 IL_CMD(MANAGEMENT_ASSOC_RESP); 165 IL_CMD(MANAGEMENT_REASSOC_REQ); 166 IL_CMD(MANAGEMENT_REASSOC_RESP); 167 IL_CMD(MANAGEMENT_PROBE_REQ); 168 IL_CMD(MANAGEMENT_PROBE_RESP); 169 IL_CMD(MANAGEMENT_BEACON); 170 IL_CMD(MANAGEMENT_ATIM); 171 IL_CMD(MANAGEMENT_DISASSOC); 172 IL_CMD(MANAGEMENT_AUTH); 173 IL_CMD(MANAGEMENT_DEAUTH); 174 IL_CMD(MANAGEMENT_ACTION); 175 default: 176 return "UNKNOWN"; 177 178 } 179} 180 181static const char * 182il_get_ctrl_string(int cmd) 183{ 184 switch (cmd) { 185 IL_CMD(CONTROL_BACK_REQ); 186 IL_CMD(CONTROL_BACK); 187 IL_CMD(CONTROL_PSPOLL); 188 IL_CMD(CONTROL_RTS); 189 IL_CMD(CONTROL_CTS); 190 IL_CMD(CONTROL_ACK); 191 IL_CMD(CONTROL_CFEND); 192 IL_CMD(CONTROL_CFENDACK); 193 default: 194 return "UNKNOWN"; 195 196 } 197} 198 199static ssize_t 200il_dbgfs_tx_stats_read(struct file *file, char __user *user_buf, size_t count, 201 loff_t *ppos) 202{ 203 204 struct il_priv *il = file->private_data; 205 char *buf; 206 int pos = 0; 207 208 int cnt; 209 ssize_t ret; 210 const size_t bufsz = 211 100 + sizeof(char) * 50 * (MANAGEMENT_MAX + CONTROL_MAX); 212 buf = kzalloc(bufsz, GFP_KERNEL); 213 if (!buf) 214 return -ENOMEM; 215 pos += scnprintf(buf + pos, bufsz - pos, "Management:\n"); 216 for (cnt = 0; cnt < MANAGEMENT_MAX; cnt++) { 217 pos += 218 scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n", 219 il_get_mgmt_string(cnt), il->tx_stats.mgmt[cnt]); 220 } 221 pos += scnprintf(buf + pos, bufsz - pos, "Control\n"); 222 for (cnt = 0; cnt < CONTROL_MAX; cnt++) { 223 pos += 224 scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n", 225 il_get_ctrl_string(cnt), il->tx_stats.ctrl[cnt]); 226 } 227 pos += scnprintf(buf + pos, bufsz - pos, "Data:\n"); 228 pos += 229 scnprintf(buf + pos, bufsz - pos, "\tcnt: %u\n", 230 il->tx_stats.data_cnt); 231 pos += 232 scnprintf(buf + pos, bufsz - pos, "\tbytes: %llu\n", 233 il->tx_stats.data_bytes); 234 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); 235 kfree(buf); 236 return ret; 237} 238 239static ssize_t 240il_dbgfs_clear_traffic_stats_write(struct file *file, 241 const char __user *user_buf, size_t count, 242 loff_t *ppos) 243{ 244 struct il_priv *il = file->private_data; 245 u32 clear_flag; 246 char buf[8]; 247 int buf_size; 248 249 memset(buf, 0, sizeof(buf)); 250 buf_size = min(count, sizeof(buf) - 1); 251 if (copy_from_user(buf, user_buf, buf_size)) 252 return -EFAULT; 253 if (sscanf(buf, "%x", &clear_flag) != 1) 254 return -EFAULT; 255 il_clear_traffic_stats(il); 256 257 return count; 258} 259 260static ssize_t 261il_dbgfs_rx_stats_read(struct file *file, char __user *user_buf, size_t count, 262 loff_t *ppos) 263{ 264 265 struct il_priv *il = file->private_data; 266 char *buf; 267 int pos = 0; 268 int cnt; 269 ssize_t ret; 270 const size_t bufsz = 271 100 + sizeof(char) * 50 * (MANAGEMENT_MAX + CONTROL_MAX); 272 buf = kzalloc(bufsz, GFP_KERNEL); 273 if (!buf) 274 return -ENOMEM; 275 276 pos += scnprintf(buf + pos, bufsz - pos, "Management:\n"); 277 for (cnt = 0; cnt < MANAGEMENT_MAX; cnt++) { 278 pos += 279 scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n", 280 il_get_mgmt_string(cnt), il->rx_stats.mgmt[cnt]); 281 } 282 pos += scnprintf(buf + pos, bufsz - pos, "Control:\n"); 283 for (cnt = 0; cnt < CONTROL_MAX; cnt++) { 284 pos += 285 scnprintf(buf + pos, bufsz - pos, "\t%25s\t\t: %u\n", 286 il_get_ctrl_string(cnt), il->rx_stats.ctrl[cnt]); 287 } 288 pos += scnprintf(buf + pos, bufsz - pos, "Data:\n"); 289 pos += 290 scnprintf(buf + pos, bufsz - pos, "\tcnt: %u\n", 291 il->rx_stats.data_cnt); 292 pos += 293 scnprintf(buf + pos, bufsz - pos, "\tbytes: %llu\n", 294 il->rx_stats.data_bytes); 295 296 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); 297 kfree(buf); 298 return ret; 299} 300 301#define BYTE1_MASK 0x000000ff; 302#define BYTE2_MASK 0x0000ffff; 303#define BYTE3_MASK 0x00ffffff; 304static ssize_t 305il_dbgfs_sram_read(struct file *file, char __user *user_buf, size_t count, 306 loff_t *ppos) 307{ 308 u32 val; 309 char *buf; 310 ssize_t ret; 311 int i; 312 int pos = 0; 313 struct il_priv *il = file->private_data; 314 size_t bufsz; 315 316 /* default is to dump the entire data segment */ 317 if (!il->dbgfs_sram_offset && !il->dbgfs_sram_len) { 318 il->dbgfs_sram_offset = 0x800000; 319 if (il->ucode_type == UCODE_INIT) 320 il->dbgfs_sram_len = il->ucode_init_data.len; 321 else 322 il->dbgfs_sram_len = il->ucode_data.len; 323 } 324 bufsz = 30 + il->dbgfs_sram_len * sizeof(char) * 10; 325 buf = kmalloc(bufsz, GFP_KERNEL); 326 if (!buf) 327 return -ENOMEM; 328 pos += 329 scnprintf(buf + pos, bufsz - pos, "sram_len: 0x%x\n", 330 il->dbgfs_sram_len); 331 pos += 332 scnprintf(buf + pos, bufsz - pos, "sram_offset: 0x%x\n", 333 il->dbgfs_sram_offset); 334 for (i = il->dbgfs_sram_len; i > 0; i -= 4) { 335 val = 336 il_read_targ_mem(il, 337 il->dbgfs_sram_offset + 338 il->dbgfs_sram_len - i); 339 if (i < 4) { 340 switch (i) { 341 case 1: 342 val &= BYTE1_MASK; 343 break; 344 case 2: 345 val &= BYTE2_MASK; 346 break; 347 case 3: 348 val &= BYTE3_MASK; 349 break; 350 } 351 } 352 if (!(i % 16)) 353 pos += scnprintf(buf + pos, bufsz - pos, "\n"); 354 pos += scnprintf(buf + pos, bufsz - pos, "0x%08x ", val); 355 } 356 pos += scnprintf(buf + pos, bufsz - pos, "\n"); 357 358 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); 359 kfree(buf); 360 return ret; 361} 362 363static ssize_t 364il_dbgfs_sram_write(struct file *file, const char __user *user_buf, 365 size_t count, loff_t *ppos) 366{ 367 struct il_priv *il = file->private_data; 368 char buf[64]; 369 int buf_size; 370 u32 offset, len; 371 372 memset(buf, 0, sizeof(buf)); 373 buf_size = min(count, sizeof(buf) - 1); 374 if (copy_from_user(buf, user_buf, buf_size)) 375 return -EFAULT; 376 377 if (sscanf(buf, "%x,%x", &offset, &len) == 2) { 378 il->dbgfs_sram_offset = offset; 379 il->dbgfs_sram_len = len; 380 } else { 381 il->dbgfs_sram_offset = 0; 382 il->dbgfs_sram_len = 0; 383 } 384 385 return count; 386} 387 388static ssize_t 389il_dbgfs_stations_read(struct file *file, char __user *user_buf, size_t count, 390 loff_t *ppos) 391{ 392 struct il_priv *il = file->private_data; 393 struct il_station_entry *station; 394 int max_sta = il->hw_params.max_stations; 395 char *buf; 396 int i, j, pos = 0; 397 ssize_t ret; 398 /* Add 30 for initial string */ 399 const size_t bufsz = 30 + sizeof(char) * 500 * (il->num_stations); 400 401 buf = kmalloc(bufsz, GFP_KERNEL); 402 if (!buf) 403 return -ENOMEM; 404 405 pos += 406 scnprintf(buf + pos, bufsz - pos, "num of stations: %d\n\n", 407 il->num_stations); 408 409 for (i = 0; i < max_sta; i++) { 410 station = &il->stations[i]; 411 if (!station->used) 412 continue; 413 pos += 414 scnprintf(buf + pos, bufsz - pos, 415 "station %d - addr: %pM, flags: %#x\n", i, 416 station->sta.sta.addr, 417 station->sta.station_flags_msk); 418 pos += 419 scnprintf(buf + pos, bufsz - pos, 420 "TID\tseq_num\ttxq_id\tframes\ttfds\t"); 421 pos += 422 scnprintf(buf + pos, bufsz - pos, 423 "start_idx\tbitmap\t\t\trate_n_flags\n"); 424 425 for (j = 0; j < MAX_TID_COUNT; j++) { 426 pos += 427 scnprintf(buf + pos, bufsz - pos, 428 "%d:\t%#x\t%#x\t%u\t%u\t%u\t\t%#.16llx\t%#x", 429 j, station->tid[j].seq_number, 430 station->tid[j].agg.txq_id, 431 station->tid[j].agg.frame_count, 432 station->tid[j].tfds_in_queue, 433 station->tid[j].agg.start_idx, 434 station->tid[j].agg.bitmap, 435 station->tid[j].agg.rate_n_flags); 436 437 if (station->tid[j].agg.wait_for_ba) 438 pos += 439 scnprintf(buf + pos, bufsz - pos, 440 " - waitforba"); 441 pos += scnprintf(buf + pos, bufsz - pos, "\n"); 442 } 443 444 pos += scnprintf(buf + pos, bufsz - pos, "\n"); 445 } 446 447 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); 448 kfree(buf); 449 return ret; 450} 451 452static ssize_t 453il_dbgfs_nvm_read(struct file *file, char __user *user_buf, size_t count, 454 loff_t *ppos) 455{ 456 ssize_t ret; 457 struct il_priv *il = file->private_data; 458 int pos = 0, ofs = 0, buf_size = 0; 459 const u8 *ptr; 460 char *buf; 461 u16 eeprom_ver; 462 size_t eeprom_len = il->cfg->eeprom_size; 463 buf_size = 4 * eeprom_len + 256; 464 465 if (eeprom_len % 16) { 466 IL_ERR("NVM size is not multiple of 16.\n"); 467 return -ENODATA; 468 } 469 470 ptr = il->eeprom; 471 if (!ptr) { 472 IL_ERR("Invalid EEPROM memory\n"); 473 return -ENOMEM; 474 } 475 476 /* 4 characters for byte 0xYY */ 477 buf = kzalloc(buf_size, GFP_KERNEL); 478 if (!buf) { 479 IL_ERR("Can not allocate Buffer\n"); 480 return -ENOMEM; 481 } 482 eeprom_ver = il_eeprom_query16(il, EEPROM_VERSION); 483 pos += 484 scnprintf(buf + pos, buf_size - pos, "EEPROM " "version: 0x%x\n", 485 eeprom_ver); 486 for (ofs = 0; ofs < eeprom_len; ofs += 16) { 487 pos += scnprintf(buf + pos, buf_size - pos, "0x%.4x %16ph\n", 488 ofs, ptr + ofs); 489 } 490 491 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); 492 kfree(buf); 493 return ret; 494} 495 496static ssize_t 497il_dbgfs_channels_read(struct file *file, char __user *user_buf, size_t count, 498 loff_t *ppos) 499{ 500 struct il_priv *il = file->private_data; 501 struct ieee80211_channel *channels = NULL; 502 const struct ieee80211_supported_band *supp_band = NULL; 503 int pos = 0, i, bufsz = PAGE_SIZE; 504 char *buf; 505 ssize_t ret; 506 507 if (!test_bit(S_GEO_CONFIGURED, &il->status)) 508 return -EAGAIN; 509 510 buf = kzalloc(bufsz, GFP_KERNEL); 511 if (!buf) { 512 IL_ERR("Can not allocate Buffer\n"); 513 return -ENOMEM; 514 } 515 516 supp_band = il_get_hw_mode(il, NL80211_BAND_2GHZ); 517 if (supp_band) { 518 channels = supp_band->channels; 519 520 pos += 521 scnprintf(buf + pos, bufsz - pos, 522 "Displaying %d channels in 2.4GHz band 802.11bg):\n", 523 supp_band->n_channels); 524 525 for (i = 0; i < supp_band->n_channels; i++) 526 pos += 527 scnprintf(buf + pos, bufsz - pos, 528 "%d: %ddBm: BSS%s%s, %s.\n", 529 channels[i].hw_value, 530 channels[i].max_power, 531 channels[i]. 532 flags & IEEE80211_CHAN_RADAR ? 533 " (IEEE 802.11h required)" : "", 534 ((channels[i]. 535 flags & IEEE80211_CHAN_NO_IR) || 536 (channels[i]. 537 flags & IEEE80211_CHAN_RADAR)) ? "" : 538 ", IBSS", 539 channels[i]. 540 flags & IEEE80211_CHAN_NO_IR ? 541 "passive only" : "active/passive"); 542 } 543 supp_band = il_get_hw_mode(il, NL80211_BAND_5GHZ); 544 if (supp_band) { 545 channels = supp_band->channels; 546 547 pos += 548 scnprintf(buf + pos, bufsz - pos, 549 "Displaying %d channels in 5.2GHz band (802.11a)\n", 550 supp_band->n_channels); 551 552 for (i = 0; i < supp_band->n_channels; i++) 553 pos += 554 scnprintf(buf + pos, bufsz - pos, 555 "%d: %ddBm: BSS%s%s, %s.\n", 556 channels[i].hw_value, 557 channels[i].max_power, 558 channels[i]. 559 flags & IEEE80211_CHAN_RADAR ? 560 " (IEEE 802.11h required)" : "", 561 ((channels[i]. 562 flags & IEEE80211_CHAN_NO_IR) || 563 (channels[i]. 564 flags & IEEE80211_CHAN_RADAR)) ? "" : 565 ", IBSS", 566 channels[i]. 567 flags & IEEE80211_CHAN_NO_IR ? 568 "passive only" : "active/passive"); 569 } 570 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); 571 kfree(buf); 572 return ret; 573} 574 575static ssize_t 576il_dbgfs_status_read(struct file *file, char __user *user_buf, size_t count, 577 loff_t *ppos) 578{ 579 580 struct il_priv *il = file->private_data; 581 char buf[512]; 582 int pos = 0; 583 const size_t bufsz = sizeof(buf); 584 585 pos += 586 scnprintf(buf + pos, bufsz - pos, "S_HCMD_ACTIVE:\t %d\n", 587 test_bit(S_HCMD_ACTIVE, &il->status)); 588 pos += 589 scnprintf(buf + pos, bufsz - pos, "S_INT_ENABLED:\t %d\n", 590 test_bit(S_INT_ENABLED, &il->status)); 591 pos += 592 scnprintf(buf + pos, bufsz - pos, "S_RFKILL:\t %d\n", 593 test_bit(S_RFKILL, &il->status)); 594 pos += 595 scnprintf(buf + pos, bufsz - pos, "S_CT_KILL:\t\t %d\n", 596 test_bit(S_CT_KILL, &il->status)); 597 pos += 598 scnprintf(buf + pos, bufsz - pos, "S_INIT:\t\t %d\n", 599 test_bit(S_INIT, &il->status)); 600 pos += 601 scnprintf(buf + pos, bufsz - pos, "S_ALIVE:\t\t %d\n", 602 test_bit(S_ALIVE, &il->status)); 603 pos += 604 scnprintf(buf + pos, bufsz - pos, "S_READY:\t\t %d\n", 605 test_bit(S_READY, &il->status)); 606 pos += 607 scnprintf(buf + pos, bufsz - pos, "S_TEMPERATURE:\t %d\n", 608 test_bit(S_TEMPERATURE, &il->status)); 609 pos += 610 scnprintf(buf + pos, bufsz - pos, "S_GEO_CONFIGURED:\t %d\n", 611 test_bit(S_GEO_CONFIGURED, &il->status)); 612 pos += 613 scnprintf(buf + pos, bufsz - pos, "S_EXIT_PENDING:\t %d\n", 614 test_bit(S_EXIT_PENDING, &il->status)); 615 pos += 616 scnprintf(buf + pos, bufsz - pos, "S_STATS:\t %d\n", 617 test_bit(S_STATS, &il->status)); 618 pos += 619 scnprintf(buf + pos, bufsz - pos, "S_SCANNING:\t %d\n", 620 test_bit(S_SCANNING, &il->status)); 621 pos += 622 scnprintf(buf + pos, bufsz - pos, "S_SCAN_ABORTING:\t %d\n", 623 test_bit(S_SCAN_ABORTING, &il->status)); 624 pos += 625 scnprintf(buf + pos, bufsz - pos, "S_SCAN_HW:\t\t %d\n", 626 test_bit(S_SCAN_HW, &il->status)); 627 pos += 628 scnprintf(buf + pos, bufsz - pos, "S_POWER_PMI:\t %d\n", 629 test_bit(S_POWER_PMI, &il->status)); 630 pos += 631 scnprintf(buf + pos, bufsz - pos, "S_FW_ERROR:\t %d\n", 632 test_bit(S_FW_ERROR, &il->status)); 633 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 634} 635 636static ssize_t 637il_dbgfs_interrupt_read(struct file *file, char __user *user_buf, size_t count, 638 loff_t *ppos) 639{ 640 641 struct il_priv *il = file->private_data; 642 int pos = 0; 643 int cnt = 0; 644 char *buf; 645 int bufsz = 24 * 64; /* 24 items * 64 char per item */ 646 ssize_t ret; 647 648 buf = kzalloc(bufsz, GFP_KERNEL); 649 if (!buf) { 650 IL_ERR("Can not allocate Buffer\n"); 651 return -ENOMEM; 652 } 653 654 pos += 655 scnprintf(buf + pos, bufsz - pos, "Interrupt Statistics Report:\n"); 656 657 pos += 658 scnprintf(buf + pos, bufsz - pos, "HW Error:\t\t\t %u\n", 659 il->isr_stats.hw); 660 pos += 661 scnprintf(buf + pos, bufsz - pos, "SW Error:\t\t\t %u\n", 662 il->isr_stats.sw); 663 if (il->isr_stats.sw || il->isr_stats.hw) { 664 pos += 665 scnprintf(buf + pos, bufsz - pos, 666 "\tLast Restarting Code: 0x%X\n", 667 il->isr_stats.err_code); 668 } 669#ifdef CONFIG_IWLEGACY_DEBUG 670 pos += 671 scnprintf(buf + pos, bufsz - pos, "Frame transmitted:\t\t %u\n", 672 il->isr_stats.sch); 673 pos += 674 scnprintf(buf + pos, bufsz - pos, "Alive interrupt:\t\t %u\n", 675 il->isr_stats.alive); 676#endif 677 pos += 678 scnprintf(buf + pos, bufsz - pos, 679 "HW RF KILL switch toggled:\t %u\n", 680 il->isr_stats.rfkill); 681 682 pos += 683 scnprintf(buf + pos, bufsz - pos, "CT KILL:\t\t\t %u\n", 684 il->isr_stats.ctkill); 685 686 pos += 687 scnprintf(buf + pos, bufsz - pos, "Wakeup Interrupt:\t\t %u\n", 688 il->isr_stats.wakeup); 689 690 pos += 691 scnprintf(buf + pos, bufsz - pos, "Rx command responses:\t\t %u\n", 692 il->isr_stats.rx); 693 for (cnt = 0; cnt < IL_CN_MAX; cnt++) { 694 if (il->isr_stats.handlers[cnt] > 0) 695 pos += 696 scnprintf(buf + pos, bufsz - pos, 697 "\tRx handler[%36s]:\t\t %u\n", 698 il_get_cmd_string(cnt), 699 il->isr_stats.handlers[cnt]); 700 } 701 702 pos += 703 scnprintf(buf + pos, bufsz - pos, "Tx/FH interrupt:\t\t %u\n", 704 il->isr_stats.tx); 705 706 pos += 707 scnprintf(buf + pos, bufsz - pos, "Unexpected INTA:\t\t %u\n", 708 il->isr_stats.unhandled); 709 710 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); 711 kfree(buf); 712 return ret; 713} 714 715static ssize_t 716il_dbgfs_interrupt_write(struct file *file, const char __user *user_buf, 717 size_t count, loff_t *ppos) 718{ 719 struct il_priv *il = file->private_data; 720 char buf[8]; 721 int buf_size; 722 u32 reset_flag; 723 724 memset(buf, 0, sizeof(buf)); 725 buf_size = min(count, sizeof(buf) - 1); 726 if (copy_from_user(buf, user_buf, buf_size)) 727 return -EFAULT; 728 if (sscanf(buf, "%x", &reset_flag) != 1) 729 return -EFAULT; 730 if (reset_flag == 0) 731 il_clear_isr_stats(il); 732 733 return count; 734} 735 736static ssize_t 737il_dbgfs_qos_read(struct file *file, char __user *user_buf, size_t count, 738 loff_t *ppos) 739{ 740 struct il_priv *il = file->private_data; 741 int pos = 0, i; 742 char buf[256]; 743 const size_t bufsz = sizeof(buf); 744 745 for (i = 0; i < AC_NUM; i++) { 746 pos += 747 scnprintf(buf + pos, bufsz - pos, 748 "\tcw_min\tcw_max\taifsn\ttxop\n"); 749 pos += 750 scnprintf(buf + pos, bufsz - pos, 751 "AC[%d]\t%u\t%u\t%u\t%u\n", i, 752 il->qos_data.def_qos_parm.ac[i].cw_min, 753 il->qos_data.def_qos_parm.ac[i].cw_max, 754 il->qos_data.def_qos_parm.ac[i].aifsn, 755 il->qos_data.def_qos_parm.ac[i].edca_txop); 756 } 757 758 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 759} 760 761static ssize_t 762il_dbgfs_disable_ht40_write(struct file *file, const char __user *user_buf, 763 size_t count, loff_t *ppos) 764{ 765 struct il_priv *il = file->private_data; 766 char buf[8]; 767 int buf_size; 768 int ht40; 769 770 memset(buf, 0, sizeof(buf)); 771 buf_size = min(count, sizeof(buf) - 1); 772 if (copy_from_user(buf, user_buf, buf_size)) 773 return -EFAULT; 774 if (sscanf(buf, "%d", &ht40) != 1) 775 return -EFAULT; 776 if (!il_is_any_associated(il)) 777 il->disable_ht40 = ht40 ? true : false; 778 else { 779 IL_ERR("Sta associated with AP - " 780 "Change to 40MHz channel support is not allowed\n"); 781 return -EINVAL; 782 } 783 784 return count; 785} 786 787static ssize_t 788il_dbgfs_disable_ht40_read(struct file *file, char __user *user_buf, 789 size_t count, loff_t *ppos) 790{ 791 struct il_priv *il = file->private_data; 792 char buf[100]; 793 int pos = 0; 794 const size_t bufsz = sizeof(buf); 795 796 pos += 797 scnprintf(buf + pos, bufsz - pos, "11n 40MHz Mode: %s\n", 798 il->disable_ht40 ? "Disabled" : "Enabled"); 799 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 800} 801 802DEBUGFS_READ_WRITE_FILE_OPS(sram); 803DEBUGFS_READ_FILE_OPS(nvm); 804DEBUGFS_READ_FILE_OPS(stations); 805DEBUGFS_READ_FILE_OPS(channels); 806DEBUGFS_READ_FILE_OPS(status); 807DEBUGFS_READ_WRITE_FILE_OPS(interrupt); 808DEBUGFS_READ_FILE_OPS(qos); 809DEBUGFS_READ_WRITE_FILE_OPS(disable_ht40); 810 811static ssize_t 812il_dbgfs_tx_queue_read(struct file *file, char __user *user_buf, size_t count, 813 loff_t *ppos) 814{ 815 816 struct il_priv *il = file->private_data; 817 struct il_tx_queue *txq; 818 struct il_queue *q; 819 char *buf; 820 int pos = 0; 821 int cnt; 822 int ret; 823 const size_t bufsz = 824 sizeof(char) * 64 * il->cfg->num_of_queues; 825 826 if (!il->txq) { 827 IL_ERR("txq not ready\n"); 828 return -EAGAIN; 829 } 830 buf = kzalloc(bufsz, GFP_KERNEL); 831 if (!buf) 832 return -ENOMEM; 833 834 for (cnt = 0; cnt < il->hw_params.max_txq_num; cnt++) { 835 txq = &il->txq[cnt]; 836 q = &txq->q; 837 pos += 838 scnprintf(buf + pos, bufsz - pos, 839 "hwq %.2d: read=%u write=%u stop=%d" 840 " swq_id=%#.2x (ac %d/hwq %d)\n", cnt, 841 q->read_ptr, q->write_ptr, 842 !!test_bit(cnt, il->queue_stopped), 843 txq->swq_id, txq->swq_id & 3, 844 (txq->swq_id >> 2) & 0x1f); 845 if (cnt >= 4) 846 continue; 847 /* for the ACs, display the stop count too */ 848 pos += 849 scnprintf(buf + pos, bufsz - pos, 850 " stop-count: %d\n", 851 atomic_read(&il->queue_stop_count[cnt])); 852 } 853 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); 854 kfree(buf); 855 return ret; 856} 857 858static ssize_t 859il_dbgfs_rx_queue_read(struct file *file, char __user *user_buf, size_t count, 860 loff_t *ppos) 861{ 862 863 struct il_priv *il = file->private_data; 864 struct il_rx_queue *rxq = &il->rxq; 865 char buf[256]; 866 int pos = 0; 867 const size_t bufsz = sizeof(buf); 868 869 pos += scnprintf(buf + pos, bufsz - pos, "read: %u\n", rxq->read); 870 pos += scnprintf(buf + pos, bufsz - pos, "write: %u\n", rxq->write); 871 pos += 872 scnprintf(buf + pos, bufsz - pos, "free_count: %u\n", 873 rxq->free_count); 874 if (rxq->rb_stts) { 875 pos += 876 scnprintf(buf + pos, bufsz - pos, "closed_rb_num: %u\n", 877 le16_to_cpu(rxq->rb_stts-> 878 closed_rb_num) & 0x0FFF); 879 } else { 880 pos += 881 scnprintf(buf + pos, bufsz - pos, 882 "closed_rb_num: Not Allocated\n"); 883 } 884 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 885} 886 887static ssize_t 888il_dbgfs_ucode_rx_stats_read(struct file *file, char __user *user_buf, 889 size_t count, loff_t *ppos) 890{ 891 struct il_priv *il = file->private_data; 892 893 return il->debugfs_ops->rx_stats_read(file, user_buf, count, ppos); 894} 895 896static ssize_t 897il_dbgfs_ucode_tx_stats_read(struct file *file, char __user *user_buf, 898 size_t count, loff_t *ppos) 899{ 900 struct il_priv *il = file->private_data; 901 902 return il->debugfs_ops->tx_stats_read(file, user_buf, count, ppos); 903} 904 905static ssize_t 906il_dbgfs_ucode_general_stats_read(struct file *file, char __user *user_buf, 907 size_t count, loff_t *ppos) 908{ 909 struct il_priv *il = file->private_data; 910 911 return il->debugfs_ops->general_stats_read(file, user_buf, count, ppos); 912} 913 914static ssize_t 915il_dbgfs_sensitivity_read(struct file *file, char __user *user_buf, 916 size_t count, loff_t *ppos) 917{ 918 919 struct il_priv *il = file->private_data; 920 int pos = 0; 921 int cnt = 0; 922 char *buf; 923 int bufsz = sizeof(struct il_sensitivity_data) * 4 + 100; 924 ssize_t ret; 925 struct il_sensitivity_data *data; 926 927 data = &il->sensitivity_data; 928 buf = kzalloc(bufsz, GFP_KERNEL); 929 if (!buf) { 930 IL_ERR("Can not allocate Buffer\n"); 931 return -ENOMEM; 932 } 933 934 pos += 935 scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm:\t\t\t %u\n", 936 data->auto_corr_ofdm); 937 pos += 938 scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_mrc:\t\t %u\n", 939 data->auto_corr_ofdm_mrc); 940 pos += 941 scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_x1:\t\t %u\n", 942 data->auto_corr_ofdm_x1); 943 pos += 944 scnprintf(buf + pos, bufsz - pos, "auto_corr_ofdm_mrc_x1:\t\t %u\n", 945 data->auto_corr_ofdm_mrc_x1); 946 pos += 947 scnprintf(buf + pos, bufsz - pos, "auto_corr_cck:\t\t\t %u\n", 948 data->auto_corr_cck); 949 pos += 950 scnprintf(buf + pos, bufsz - pos, "auto_corr_cck_mrc:\t\t %u\n", 951 data->auto_corr_cck_mrc); 952 pos += 953 scnprintf(buf + pos, bufsz - pos, 954 "last_bad_plcp_cnt_ofdm:\t\t %u\n", 955 data->last_bad_plcp_cnt_ofdm); 956 pos += 957 scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_ofdm:\t\t %u\n", 958 data->last_fa_cnt_ofdm); 959 pos += 960 scnprintf(buf + pos, bufsz - pos, "last_bad_plcp_cnt_cck:\t\t %u\n", 961 data->last_bad_plcp_cnt_cck); 962 pos += 963 scnprintf(buf + pos, bufsz - pos, "last_fa_cnt_cck:\t\t %u\n", 964 data->last_fa_cnt_cck); 965 pos += 966 scnprintf(buf + pos, bufsz - pos, "nrg_curr_state:\t\t\t %u\n", 967 data->nrg_curr_state); 968 pos += 969 scnprintf(buf + pos, bufsz - pos, "nrg_prev_state:\t\t\t %u\n", 970 data->nrg_prev_state); 971 pos += scnprintf(buf + pos, bufsz - pos, "nrg_value:\t\t\t"); 972 for (cnt = 0; cnt < 10; cnt++) { 973 pos += 974 scnprintf(buf + pos, bufsz - pos, " %u", 975 data->nrg_value[cnt]); 976 } 977 pos += scnprintf(buf + pos, bufsz - pos, "\n"); 978 pos += scnprintf(buf + pos, bufsz - pos, "nrg_silence_rssi:\t\t"); 979 for (cnt = 0; cnt < NRG_NUM_PREV_STAT_L; cnt++) { 980 pos += 981 scnprintf(buf + pos, bufsz - pos, " %u", 982 data->nrg_silence_rssi[cnt]); 983 } 984 pos += scnprintf(buf + pos, bufsz - pos, "\n"); 985 pos += 986 scnprintf(buf + pos, bufsz - pos, "nrg_silence_ref:\t\t %u\n", 987 data->nrg_silence_ref); 988 pos += 989 scnprintf(buf + pos, bufsz - pos, "nrg_energy_idx:\t\t\t %u\n", 990 data->nrg_energy_idx); 991 pos += 992 scnprintf(buf + pos, bufsz - pos, "nrg_silence_idx:\t\t %u\n", 993 data->nrg_silence_idx); 994 pos += 995 scnprintf(buf + pos, bufsz - pos, "nrg_th_cck:\t\t\t %u\n", 996 data->nrg_th_cck); 997 pos += 998 scnprintf(buf + pos, bufsz - pos, 999 "nrg_auto_corr_silence_diff:\t %u\n", 1000 data->nrg_auto_corr_silence_diff); 1001 pos += 1002 scnprintf(buf + pos, bufsz - pos, "num_in_cck_no_fa:\t\t %u\n", 1003 data->num_in_cck_no_fa); 1004 pos += 1005 scnprintf(buf + pos, bufsz - pos, "nrg_th_ofdm:\t\t\t %u\n", 1006 data->nrg_th_ofdm); 1007 1008 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); 1009 kfree(buf); 1010 return ret; 1011} 1012 1013static ssize_t 1014il_dbgfs_chain_noise_read(struct file *file, char __user *user_buf, 1015 size_t count, loff_t *ppos) 1016{ 1017 1018 struct il_priv *il = file->private_data; 1019 int pos = 0; 1020 int cnt = 0; 1021 char *buf; 1022 int bufsz = sizeof(struct il_chain_noise_data) * 4 + 100; 1023 ssize_t ret; 1024 struct il_chain_noise_data *data; 1025 1026 data = &il->chain_noise_data; 1027 buf = kzalloc(bufsz, GFP_KERNEL); 1028 if (!buf) { 1029 IL_ERR("Can not allocate Buffer\n"); 1030 return -ENOMEM; 1031 } 1032 1033 pos += 1034 scnprintf(buf + pos, bufsz - pos, "active_chains:\t\t\t %u\n", 1035 data->active_chains); 1036 pos += 1037 scnprintf(buf + pos, bufsz - pos, "chain_noise_a:\t\t\t %u\n", 1038 data->chain_noise_a); 1039 pos += 1040 scnprintf(buf + pos, bufsz - pos, "chain_noise_b:\t\t\t %u\n", 1041 data->chain_noise_b); 1042 pos += 1043 scnprintf(buf + pos, bufsz - pos, "chain_noise_c:\t\t\t %u\n", 1044 data->chain_noise_c); 1045 pos += 1046 scnprintf(buf + pos, bufsz - pos, "chain_signal_a:\t\t\t %u\n", 1047 data->chain_signal_a); 1048 pos += 1049 scnprintf(buf + pos, bufsz - pos, "chain_signal_b:\t\t\t %u\n", 1050 data->chain_signal_b); 1051 pos += 1052 scnprintf(buf + pos, bufsz - pos, "chain_signal_c:\t\t\t %u\n", 1053 data->chain_signal_c); 1054 pos += 1055 scnprintf(buf + pos, bufsz - pos, "beacon_count:\t\t\t %u\n", 1056 data->beacon_count); 1057 1058 pos += scnprintf(buf + pos, bufsz - pos, "disconn_array:\t\t\t"); 1059 for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) { 1060 pos += 1061 scnprintf(buf + pos, bufsz - pos, " %u", 1062 data->disconn_array[cnt]); 1063 } 1064 pos += scnprintf(buf + pos, bufsz - pos, "\n"); 1065 pos += scnprintf(buf + pos, bufsz - pos, "delta_gain_code:\t\t"); 1066 for (cnt = 0; cnt < NUM_RX_CHAINS; cnt++) { 1067 pos += 1068 scnprintf(buf + pos, bufsz - pos, " %u", 1069 data->delta_gain_code[cnt]); 1070 } 1071 pos += scnprintf(buf + pos, bufsz - pos, "\n"); 1072 pos += 1073 scnprintf(buf + pos, bufsz - pos, "radio_write:\t\t\t %u\n", 1074 data->radio_write); 1075 pos += 1076 scnprintf(buf + pos, bufsz - pos, "state:\t\t\t\t %u\n", 1077 data->state); 1078 1079 ret = simple_read_from_buffer(user_buf, count, ppos, buf, pos); 1080 kfree(buf); 1081 return ret; 1082} 1083 1084static ssize_t 1085il_dbgfs_power_save_status_read(struct file *file, char __user *user_buf, 1086 size_t count, loff_t *ppos) 1087{ 1088 struct il_priv *il = file->private_data; 1089 char buf[60]; 1090 int pos = 0; 1091 const size_t bufsz = sizeof(buf); 1092 u32 pwrsave_status; 1093 1094 pwrsave_status = 1095 _il_rd(il, CSR_GP_CNTRL) & CSR_GP_REG_POWER_SAVE_STATUS_MSK; 1096 1097 pos += scnprintf(buf + pos, bufsz - pos, "Power Save Status: "); 1098 pos += 1099 scnprintf(buf + pos, bufsz - pos, "%s\n", 1100 (pwrsave_status == CSR_GP_REG_NO_POWER_SAVE) ? "none" : 1101 (pwrsave_status == CSR_GP_REG_MAC_POWER_SAVE) ? "MAC" : 1102 (pwrsave_status == CSR_GP_REG_PHY_POWER_SAVE) ? "PHY" : 1103 "error"); 1104 1105 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 1106} 1107 1108static ssize_t 1109il_dbgfs_clear_ucode_stats_write(struct file *file, 1110 const char __user *user_buf, size_t count, 1111 loff_t *ppos) 1112{ 1113 struct il_priv *il = file->private_data; 1114 char buf[8]; 1115 int buf_size; 1116 int clear; 1117 1118 memset(buf, 0, sizeof(buf)); 1119 buf_size = min(count, sizeof(buf) - 1); 1120 if (copy_from_user(buf, user_buf, buf_size)) 1121 return -EFAULT; 1122 if (sscanf(buf, "%d", &clear) != 1) 1123 return -EFAULT; 1124 1125 /* make request to uCode to retrieve stats information */ 1126 mutex_lock(&il->mutex); 1127 il_send_stats_request(il, CMD_SYNC, true); 1128 mutex_unlock(&il->mutex); 1129 1130 return count; 1131} 1132 1133static ssize_t 1134il_dbgfs_rxon_flags_read(struct file *file, char __user *user_buf, 1135 size_t count, loff_t *ppos) 1136{ 1137 1138 struct il_priv *il = file->private_data; 1139 int len = 0; 1140 char buf[20]; 1141 1142 len = sprintf(buf, "0x%04X\n", le32_to_cpu(il->active.flags)); 1143 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 1144} 1145 1146static ssize_t 1147il_dbgfs_rxon_filter_flags_read(struct file *file, char __user *user_buf, 1148 size_t count, loff_t *ppos) 1149{ 1150 1151 struct il_priv *il = file->private_data; 1152 int len = 0; 1153 char buf[20]; 1154 1155 len = 1156 sprintf(buf, "0x%04X\n", le32_to_cpu(il->active.filter_flags)); 1157 return simple_read_from_buffer(user_buf, count, ppos, buf, len); 1158} 1159 1160static ssize_t 1161il_dbgfs_fh_reg_read(struct file *file, char __user *user_buf, size_t count, 1162 loff_t *ppos) 1163{ 1164 struct il_priv *il = file->private_data; 1165 char *buf; 1166 int pos = 0; 1167 ssize_t ret = -EFAULT; 1168 1169 if (il->ops->dump_fh) { 1170 ret = pos = il->ops->dump_fh(il, &buf, true); 1171 if (buf) { 1172 ret = 1173 simple_read_from_buffer(user_buf, count, ppos, buf, 1174 pos); 1175 kfree(buf); 1176 } 1177 } 1178 1179 return ret; 1180} 1181 1182static ssize_t 1183il_dbgfs_missed_beacon_read(struct file *file, char __user *user_buf, 1184 size_t count, loff_t *ppos) 1185{ 1186 1187 struct il_priv *il = file->private_data; 1188 int pos = 0; 1189 char buf[12]; 1190 const size_t bufsz = sizeof(buf); 1191 1192 pos += 1193 scnprintf(buf + pos, bufsz - pos, "%d\n", 1194 il->missed_beacon_threshold); 1195 1196 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 1197} 1198 1199static ssize_t 1200il_dbgfs_missed_beacon_write(struct file *file, const char __user *user_buf, 1201 size_t count, loff_t *ppos) 1202{ 1203 struct il_priv *il = file->private_data; 1204 char buf[8]; 1205 int buf_size; 1206 int missed; 1207 1208 memset(buf, 0, sizeof(buf)); 1209 buf_size = min(count, sizeof(buf) - 1); 1210 if (copy_from_user(buf, user_buf, buf_size)) 1211 return -EFAULT; 1212 if (sscanf(buf, "%d", &missed) != 1) 1213 return -EINVAL; 1214 1215 if (missed < IL_MISSED_BEACON_THRESHOLD_MIN || 1216 missed > IL_MISSED_BEACON_THRESHOLD_MAX) 1217 il->missed_beacon_threshold = IL_MISSED_BEACON_THRESHOLD_DEF; 1218 else 1219 il->missed_beacon_threshold = missed; 1220 1221 return count; 1222} 1223 1224static ssize_t 1225il_dbgfs_force_reset_read(struct file *file, char __user *user_buf, 1226 size_t count, loff_t *ppos) 1227{ 1228 1229 struct il_priv *il = file->private_data; 1230 int pos = 0; 1231 char buf[300]; 1232 const size_t bufsz = sizeof(buf); 1233 struct il_force_reset *force_reset; 1234 1235 force_reset = &il->force_reset; 1236 1237 pos += 1238 scnprintf(buf + pos, bufsz - pos, "\tnumber of reset request: %d\n", 1239 force_reset->reset_request_count); 1240 pos += 1241 scnprintf(buf + pos, bufsz - pos, 1242 "\tnumber of reset request success: %d\n", 1243 force_reset->reset_success_count); 1244 pos += 1245 scnprintf(buf + pos, bufsz - pos, 1246 "\tnumber of reset request reject: %d\n", 1247 force_reset->reset_reject_count); 1248 pos += 1249 scnprintf(buf + pos, bufsz - pos, "\treset duration: %lu\n", 1250 force_reset->reset_duration); 1251 1252 return simple_read_from_buffer(user_buf, count, ppos, buf, pos); 1253} 1254 1255static ssize_t 1256il_dbgfs_force_reset_write(struct file *file, const char __user *user_buf, 1257 size_t count, loff_t *ppos) 1258{ 1259 1260 int ret; 1261 struct il_priv *il = file->private_data; 1262 1263 ret = il_force_reset(il, true); 1264 1265 return ret ? ret : count; 1266} 1267 1268static ssize_t 1269il_dbgfs_wd_timeout_write(struct file *file, const char __user *user_buf, 1270 size_t count, loff_t *ppos) 1271{ 1272 1273 struct il_priv *il = file->private_data; 1274 char buf[8]; 1275 int buf_size; 1276 int timeout; 1277 1278 memset(buf, 0, sizeof(buf)); 1279 buf_size = min(count, sizeof(buf) - 1); 1280 if (copy_from_user(buf, user_buf, buf_size)) 1281 return -EFAULT; 1282 if (sscanf(buf, "%d", &timeout) != 1) 1283 return -EINVAL; 1284 if (timeout < 0 || timeout > IL_MAX_WD_TIMEOUT) 1285 timeout = IL_DEF_WD_TIMEOUT; 1286 1287 il->cfg->wd_timeout = timeout; 1288 il_setup_watchdog(il); 1289 return count; 1290} 1291 1292DEBUGFS_READ_FILE_OPS(rx_stats); 1293DEBUGFS_READ_FILE_OPS(tx_stats); 1294DEBUGFS_READ_FILE_OPS(rx_queue); 1295DEBUGFS_READ_FILE_OPS(tx_queue); 1296DEBUGFS_READ_FILE_OPS(ucode_rx_stats); 1297DEBUGFS_READ_FILE_OPS(ucode_tx_stats); 1298DEBUGFS_READ_FILE_OPS(ucode_general_stats); 1299DEBUGFS_READ_FILE_OPS(sensitivity); 1300DEBUGFS_READ_FILE_OPS(chain_noise); 1301DEBUGFS_READ_FILE_OPS(power_save_status); 1302DEBUGFS_WRITE_FILE_OPS(clear_ucode_stats); 1303DEBUGFS_WRITE_FILE_OPS(clear_traffic_stats); 1304DEBUGFS_READ_FILE_OPS(fh_reg); 1305DEBUGFS_READ_WRITE_FILE_OPS(missed_beacon); 1306DEBUGFS_READ_WRITE_FILE_OPS(force_reset); 1307DEBUGFS_READ_FILE_OPS(rxon_flags); 1308DEBUGFS_READ_FILE_OPS(rxon_filter_flags); 1309DEBUGFS_WRITE_FILE_OPS(wd_timeout); 1310 1311/* 1312 * Create the debugfs files and directories 1313 * 1314 */ 1315void 1316il_dbgfs_register(struct il_priv *il, const char *name) 1317{ 1318 struct dentry *phyd = il->hw->wiphy->debugfsdir; 1319 struct dentry *dir_drv, *dir_data, *dir_rf, *dir_debug; 1320 1321 dir_drv = debugfs_create_dir(name, phyd); 1322 il->debugfs_dir = dir_drv; 1323 1324 dir_data = debugfs_create_dir("data", dir_drv); 1325 dir_rf = debugfs_create_dir("rf", dir_drv); 1326 dir_debug = debugfs_create_dir("debug", dir_drv); 1327 1328 DEBUGFS_ADD_FILE(nvm, dir_data, 0400); 1329 DEBUGFS_ADD_FILE(sram, dir_data, 0600); 1330 DEBUGFS_ADD_FILE(stations, dir_data, 0400); 1331 DEBUGFS_ADD_FILE(channels, dir_data, 0400); 1332 DEBUGFS_ADD_FILE(status, dir_data, 0400); 1333 DEBUGFS_ADD_FILE(interrupt, dir_data, 0600); 1334 DEBUGFS_ADD_FILE(qos, dir_data, 0400); 1335 DEBUGFS_ADD_FILE(disable_ht40, dir_data, 0600); 1336 DEBUGFS_ADD_FILE(rx_stats, dir_debug, 0400); 1337 DEBUGFS_ADD_FILE(tx_stats, dir_debug, 0400); 1338 DEBUGFS_ADD_FILE(rx_queue, dir_debug, 0400); 1339 DEBUGFS_ADD_FILE(tx_queue, dir_debug, 0400); 1340 DEBUGFS_ADD_FILE(power_save_status, dir_debug, 0400); 1341 DEBUGFS_ADD_FILE(clear_ucode_stats, dir_debug, 0200); 1342 DEBUGFS_ADD_FILE(clear_traffic_stats, dir_debug, 0200); 1343 DEBUGFS_ADD_FILE(fh_reg, dir_debug, 0400); 1344 DEBUGFS_ADD_FILE(missed_beacon, dir_debug, 0200); 1345 DEBUGFS_ADD_FILE(force_reset, dir_debug, 0600); 1346 DEBUGFS_ADD_FILE(ucode_rx_stats, dir_debug, 0400); 1347 DEBUGFS_ADD_FILE(ucode_tx_stats, dir_debug, 0400); 1348 DEBUGFS_ADD_FILE(ucode_general_stats, dir_debug, 0400); 1349 1350 if (il->cfg->sensitivity_calib_by_driver) 1351 DEBUGFS_ADD_FILE(sensitivity, dir_debug, 0400); 1352 if (il->cfg->chain_noise_calib_by_driver) 1353 DEBUGFS_ADD_FILE(chain_noise, dir_debug, 0400); 1354 DEBUGFS_ADD_FILE(rxon_flags, dir_debug, 0200); 1355 DEBUGFS_ADD_FILE(rxon_filter_flags, dir_debug, 0200); 1356 DEBUGFS_ADD_FILE(wd_timeout, dir_debug, 0200); 1357 if (il->cfg->sensitivity_calib_by_driver) 1358 DEBUGFS_ADD_BOOL(disable_sensitivity, dir_rf, 1359 &il->disable_sens_cal); 1360 if (il->cfg->chain_noise_calib_by_driver) 1361 DEBUGFS_ADD_BOOL(disable_chain_noise, dir_rf, 1362 &il->disable_chain_noise_cal); 1363 DEBUGFS_ADD_BOOL(disable_tx_power, dir_rf, &il->disable_tx_power_cal); 1364} 1365EXPORT_SYMBOL(il_dbgfs_register); 1366 1367/* 1368 * Remove the debugfs files and directories 1369 */ 1370void 1371il_dbgfs_unregister(struct il_priv *il) 1372{ 1373 if (!il->debugfs_dir) 1374 return; 1375 1376 debugfs_remove_recursive(il->debugfs_dir); 1377 il->debugfs_dir = NULL; 1378} 1379EXPORT_SYMBOL(il_dbgfs_unregister); 1380