1 /* 2 Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com> 3 <http://rt2x00.serialmonkey.com> 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by 7 the Free Software Foundation; either version 2 of the License, or 8 (at your option) any later version. 9 10 This program is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 GNU General Public License for more details. 14 15 You should have received a copy of the GNU General Public License 16 along with this program; if not, see <http://www.gnu.org/licenses/>. 17 */ 18 19 /* 20 Module: rt2x00lib 21 Abstract: rt2x00 debugfs specific routines. 22 */ 23 24 #include <linux/debugfs.h> 25 #include <linux/kernel.h> 26 #include <linux/module.h> 27 #include <linux/poll.h> 28 #include <linux/sched.h> 29 #include <linux/slab.h> 30 #include <linux/uaccess.h> 31 32 #include "rt2x00.h" 33 #include "rt2x00lib.h" 34 #include "rt2x00dump.h" 35 36 #define MAX_LINE_LENGTH 64 37 38 struct rt2x00debug_crypto { 39 unsigned long success; 40 unsigned long icv_error; 41 unsigned long mic_error; 42 unsigned long key_error; 43 }; 44 45 struct rt2x00debug_intf { 46 /* 47 * Pointer to driver structure where 48 * this debugfs entry belongs to. 49 */ 50 struct rt2x00_dev *rt2x00dev; 51 52 /* 53 * Reference to the rt2x00debug structure 54 * which can be used to communicate with 55 * the registers. 56 */ 57 const struct rt2x00debug *debug; 58 59 /* 60 * Debugfs entries for: 61 * - driver folder 62 * - driver file 63 * - chipset file 64 * - device state flags file 65 * - device capability flags file 66 * - register folder 67 * - csr offset/value files 68 * - eeprom offset/value files 69 * - bbp offset/value files 70 * - rf offset/value files 71 * - rfcsr offset/value files 72 * - queue folder 73 * - frame dump file 74 * - queue stats file 75 * - crypto stats file 76 */ 77 struct dentry *driver_folder; 78 struct dentry *driver_entry; 79 struct dentry *chipset_entry; 80 struct dentry *dev_flags; 81 struct dentry *cap_flags; 82 struct dentry *register_folder; 83 struct dentry *csr_off_entry; 84 struct dentry *csr_val_entry; 85 struct dentry *eeprom_off_entry; 86 struct dentry *eeprom_val_entry; 87 struct dentry *bbp_off_entry; 88 struct dentry *bbp_val_entry; 89 struct dentry *rf_off_entry; 90 struct dentry *rf_val_entry; 91 struct dentry *rfcsr_off_entry; 92 struct dentry *rfcsr_val_entry; 93 struct dentry *queue_folder; 94 struct dentry *queue_frame_dump_entry; 95 struct dentry *queue_stats_entry; 96 struct dentry *crypto_stats_entry; 97 98 /* 99 * The frame dump file only allows a single reader, 100 * so we need to store the current state here. 101 */ 102 unsigned long frame_dump_flags; 103 #define FRAME_DUMP_FILE_OPEN 1 104 105 /* 106 * We queue each frame before dumping it to the user, 107 * per read command we will pass a single skb structure 108 * so we should be prepared to queue multiple sk buffers 109 * before sending it to userspace. 110 */ 111 struct sk_buff_head frame_dump_skbqueue; 112 wait_queue_head_t frame_dump_waitqueue; 113 114 /* 115 * HW crypto statistics. 116 * All statistics are stored separately per cipher type. 117 */ 118 struct rt2x00debug_crypto crypto_stats[CIPHER_MAX]; 119 120 /* 121 * Driver and chipset files will use a data buffer 122 * that has been created in advance. This will simplify 123 * the code since we can use the debugfs functions. 124 */ 125 struct debugfs_blob_wrapper driver_blob; 126 struct debugfs_blob_wrapper chipset_blob; 127 128 /* 129 * Requested offset for each register type. 130 */ 131 unsigned int offset_csr; 132 unsigned int offset_eeprom; 133 unsigned int offset_bbp; 134 unsigned int offset_rf; 135 unsigned int offset_rfcsr; 136 }; 137 138 void rt2x00debug_update_crypto(struct rt2x00_dev *rt2x00dev, 139 struct rxdone_entry_desc *rxdesc) 140 { 141 struct rt2x00debug_intf *intf = rt2x00dev->debugfs_intf; 142 enum cipher cipher = rxdesc->cipher; 143 enum rx_crypto status = rxdesc->cipher_status; 144 145 if (cipher == CIPHER_TKIP_NO_MIC) 146 cipher = CIPHER_TKIP; 147 if (cipher == CIPHER_NONE || cipher >= CIPHER_MAX) 148 return; 149 150 /* Remove CIPHER_NONE index */ 151 cipher--; 152 153 intf->crypto_stats[cipher].success += (status == RX_CRYPTO_SUCCESS); 154 intf->crypto_stats[cipher].icv_error += (status == RX_CRYPTO_FAIL_ICV); 155 intf->crypto_stats[cipher].mic_error += (status == RX_CRYPTO_FAIL_MIC); 156 intf->crypto_stats[cipher].key_error += (status == RX_CRYPTO_FAIL_KEY); 157 } 158 159 void rt2x00debug_dump_frame(struct rt2x00_dev *rt2x00dev, 160 enum rt2x00_dump_type type, struct sk_buff *skb) 161 { 162 struct rt2x00debug_intf *intf = rt2x00dev->debugfs_intf; 163 struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb); 164 struct sk_buff *skbcopy; 165 struct rt2x00dump_hdr *dump_hdr; 166 struct timeval timestamp; 167 u32 data_len; 168 169 if (likely(!test_bit(FRAME_DUMP_FILE_OPEN, &intf->frame_dump_flags))) 170 return; 171 172 do_gettimeofday(×tamp); 173 174 if (skb_queue_len(&intf->frame_dump_skbqueue) > 20) { 175 rt2x00_dbg(rt2x00dev, "txrx dump queue length exceeded\n"); 176 return; 177 } 178 179 data_len = skb->len; 180 if (skbdesc->flags & SKBDESC_DESC_IN_SKB) 181 data_len -= skbdesc->desc_len; 182 183 skbcopy = alloc_skb(sizeof(*dump_hdr) + skbdesc->desc_len + data_len, 184 GFP_ATOMIC); 185 if (!skbcopy) { 186 rt2x00_dbg(rt2x00dev, "Failed to copy skb for dump\n"); 187 return; 188 } 189 190 dump_hdr = (struct rt2x00dump_hdr *)skb_put(skbcopy, sizeof(*dump_hdr)); 191 dump_hdr->version = cpu_to_le32(DUMP_HEADER_VERSION); 192 dump_hdr->header_length = cpu_to_le32(sizeof(*dump_hdr)); 193 dump_hdr->desc_length = cpu_to_le32(skbdesc->desc_len); 194 dump_hdr->data_length = cpu_to_le32(data_len); 195 dump_hdr->chip_rt = cpu_to_le16(rt2x00dev->chip.rt); 196 dump_hdr->chip_rf = cpu_to_le16(rt2x00dev->chip.rf); 197 dump_hdr->chip_rev = cpu_to_le16(rt2x00dev->chip.rev); 198 dump_hdr->type = cpu_to_le16(type); 199 dump_hdr->queue_index = skbdesc->entry->queue->qid; 200 dump_hdr->entry_index = skbdesc->entry->entry_idx; 201 dump_hdr->timestamp_sec = cpu_to_le32(timestamp.tv_sec); 202 dump_hdr->timestamp_usec = cpu_to_le32(timestamp.tv_usec); 203 204 if (!(skbdesc->flags & SKBDESC_DESC_IN_SKB)) 205 memcpy(skb_put(skbcopy, skbdesc->desc_len), skbdesc->desc, 206 skbdesc->desc_len); 207 memcpy(skb_put(skbcopy, skb->len), skb->data, skb->len); 208 209 skb_queue_tail(&intf->frame_dump_skbqueue, skbcopy); 210 wake_up_interruptible(&intf->frame_dump_waitqueue); 211 212 /* 213 * Verify that the file has not been closed while we were working. 214 */ 215 if (!test_bit(FRAME_DUMP_FILE_OPEN, &intf->frame_dump_flags)) 216 skb_queue_purge(&intf->frame_dump_skbqueue); 217 } 218 EXPORT_SYMBOL_GPL(rt2x00debug_dump_frame); 219 220 static int rt2x00debug_file_open(struct inode *inode, struct file *file) 221 { 222 struct rt2x00debug_intf *intf = inode->i_private; 223 224 file->private_data = inode->i_private; 225 226 if (!try_module_get(intf->debug->owner)) 227 return -EBUSY; 228 229 return 0; 230 } 231 232 static int rt2x00debug_file_release(struct inode *inode, struct file *file) 233 { 234 struct rt2x00debug_intf *intf = file->private_data; 235 236 module_put(intf->debug->owner); 237 238 return 0; 239 } 240 241 static int rt2x00debug_open_queue_dump(struct inode *inode, struct file *file) 242 { 243 struct rt2x00debug_intf *intf = inode->i_private; 244 int retval; 245 246 retval = rt2x00debug_file_open(inode, file); 247 if (retval) 248 return retval; 249 250 if (test_and_set_bit(FRAME_DUMP_FILE_OPEN, &intf->frame_dump_flags)) { 251 rt2x00debug_file_release(inode, file); 252 return -EBUSY; 253 } 254 255 return 0; 256 } 257 258 static int rt2x00debug_release_queue_dump(struct inode *inode, struct file *file) 259 { 260 struct rt2x00debug_intf *intf = inode->i_private; 261 262 skb_queue_purge(&intf->frame_dump_skbqueue); 263 264 clear_bit(FRAME_DUMP_FILE_OPEN, &intf->frame_dump_flags); 265 266 return rt2x00debug_file_release(inode, file); 267 } 268 269 static ssize_t rt2x00debug_read_queue_dump(struct file *file, 270 char __user *buf, 271 size_t length, 272 loff_t *offset) 273 { 274 struct rt2x00debug_intf *intf = file->private_data; 275 struct sk_buff *skb; 276 size_t status; 277 int retval; 278 279 if (file->f_flags & O_NONBLOCK) 280 return -EAGAIN; 281 282 retval = 283 wait_event_interruptible(intf->frame_dump_waitqueue, 284 (skb = 285 skb_dequeue(&intf->frame_dump_skbqueue))); 286 if (retval) 287 return retval; 288 289 status = min_t(size_t, skb->len, length); 290 if (copy_to_user(buf, skb->data, status)) { 291 status = -EFAULT; 292 goto exit; 293 } 294 295 *offset += status; 296 297 exit: 298 kfree_skb(skb); 299 300 return status; 301 } 302 303 static unsigned int rt2x00debug_poll_queue_dump(struct file *file, 304 poll_table *wait) 305 { 306 struct rt2x00debug_intf *intf = file->private_data; 307 308 poll_wait(file, &intf->frame_dump_waitqueue, wait); 309 310 if (!skb_queue_empty(&intf->frame_dump_skbqueue)) 311 return POLLOUT | POLLWRNORM; 312 313 return 0; 314 } 315 316 static const struct file_operations rt2x00debug_fop_queue_dump = { 317 .owner = THIS_MODULE, 318 .read = rt2x00debug_read_queue_dump, 319 .poll = rt2x00debug_poll_queue_dump, 320 .open = rt2x00debug_open_queue_dump, 321 .release = rt2x00debug_release_queue_dump, 322 .llseek = default_llseek, 323 }; 324 325 static ssize_t rt2x00debug_read_queue_stats(struct file *file, 326 char __user *buf, 327 size_t length, 328 loff_t *offset) 329 { 330 struct rt2x00debug_intf *intf = file->private_data; 331 struct data_queue *queue; 332 unsigned long irqflags; 333 unsigned int lines = 1 + intf->rt2x00dev->data_queues; 334 size_t size; 335 char *data; 336 char *temp; 337 338 if (*offset) 339 return 0; 340 341 data = kcalloc(lines, MAX_LINE_LENGTH, GFP_KERNEL); 342 if (!data) 343 return -ENOMEM; 344 345 temp = data + 346 sprintf(data, "qid\tflags\t\tcount\tlimit\tlength\tindex\tdma done\tdone\n"); 347 348 queue_for_each(intf->rt2x00dev, queue) { 349 spin_lock_irqsave(&queue->index_lock, irqflags); 350 351 temp += sprintf(temp, "%d\t0x%.8x\t%d\t%d\t%d\t%d\t%d\t\t%d\n", 352 queue->qid, (unsigned int)queue->flags, 353 queue->count, queue->limit, queue->length, 354 queue->index[Q_INDEX], 355 queue->index[Q_INDEX_DMA_DONE], 356 queue->index[Q_INDEX_DONE]); 357 358 spin_unlock_irqrestore(&queue->index_lock, irqflags); 359 } 360 361 size = strlen(data); 362 size = min(size, length); 363 364 if (copy_to_user(buf, data, size)) { 365 kfree(data); 366 return -EFAULT; 367 } 368 369 kfree(data); 370 371 *offset += size; 372 return size; 373 } 374 375 static const struct file_operations rt2x00debug_fop_queue_stats = { 376 .owner = THIS_MODULE, 377 .read = rt2x00debug_read_queue_stats, 378 .open = rt2x00debug_file_open, 379 .release = rt2x00debug_file_release, 380 .llseek = default_llseek, 381 }; 382 383 #ifdef CONFIG_RT2X00_LIB_CRYPTO 384 static ssize_t rt2x00debug_read_crypto_stats(struct file *file, 385 char __user *buf, 386 size_t length, 387 loff_t *offset) 388 { 389 struct rt2x00debug_intf *intf = file->private_data; 390 static const char * const name[] = { "WEP64", "WEP128", "TKIP", "AES" }; 391 char *data; 392 char *temp; 393 size_t size; 394 unsigned int i; 395 396 if (*offset) 397 return 0; 398 399 data = kzalloc((1 + CIPHER_MAX) * MAX_LINE_LENGTH, GFP_KERNEL); 400 if (!data) 401 return -ENOMEM; 402 403 temp = data; 404 temp += sprintf(data, "cipher\tsuccess\ticv err\tmic err\tkey err\n"); 405 406 for (i = 0; i < CIPHER_MAX; i++) { 407 temp += sprintf(temp, "%s\t%lu\t%lu\t%lu\t%lu\n", name[i], 408 intf->crypto_stats[i].success, 409 intf->crypto_stats[i].icv_error, 410 intf->crypto_stats[i].mic_error, 411 intf->crypto_stats[i].key_error); 412 } 413 414 size = strlen(data); 415 size = min(size, length); 416 417 if (copy_to_user(buf, data, size)) { 418 kfree(data); 419 return -EFAULT; 420 } 421 422 kfree(data); 423 424 *offset += size; 425 return size; 426 } 427 428 static const struct file_operations rt2x00debug_fop_crypto_stats = { 429 .owner = THIS_MODULE, 430 .read = rt2x00debug_read_crypto_stats, 431 .open = rt2x00debug_file_open, 432 .release = rt2x00debug_file_release, 433 .llseek = default_llseek, 434 }; 435 #endif 436 437 #define RT2X00DEBUGFS_OPS_READ(__name, __format, __type) \ 438 static ssize_t rt2x00debug_read_##__name(struct file *file, \ 439 char __user *buf, \ 440 size_t length, \ 441 loff_t *offset) \ 442 { \ 443 struct rt2x00debug_intf *intf = file->private_data; \ 444 const struct rt2x00debug *debug = intf->debug; \ 445 char line[16]; \ 446 size_t size; \ 447 unsigned int index = intf->offset_##__name; \ 448 __type value; \ 449 \ 450 if (*offset) \ 451 return 0; \ 452 \ 453 if (index >= debug->__name.word_count) \ 454 return -EINVAL; \ 455 \ 456 index += (debug->__name.word_base / \ 457 debug->__name.word_size); \ 458 \ 459 if (debug->__name.flags & RT2X00DEBUGFS_OFFSET) \ 460 index *= debug->__name.word_size; \ 461 \ 462 debug->__name.read(intf->rt2x00dev, index, &value); \ 463 \ 464 size = sprintf(line, __format, value); \ 465 \ 466 if (copy_to_user(buf, line, size)) \ 467 return -EFAULT; \ 468 \ 469 *offset += size; \ 470 return size; \ 471 } 472 473 #define RT2X00DEBUGFS_OPS_WRITE(__name, __type) \ 474 static ssize_t rt2x00debug_write_##__name(struct file *file, \ 475 const char __user *buf,\ 476 size_t length, \ 477 loff_t *offset) \ 478 { \ 479 struct rt2x00debug_intf *intf = file->private_data; \ 480 const struct rt2x00debug *debug = intf->debug; \ 481 char line[16]; \ 482 size_t size; \ 483 unsigned int index = intf->offset_##__name; \ 484 __type value; \ 485 \ 486 if (*offset) \ 487 return 0; \ 488 \ 489 if (index >= debug->__name.word_count) \ 490 return -EINVAL; \ 491 \ 492 if (length > sizeof(line)) \ 493 return -EINVAL; \ 494 \ 495 if (copy_from_user(line, buf, length)) \ 496 return -EFAULT; \ 497 \ 498 size = strlen(line); \ 499 value = simple_strtoul(line, NULL, 0); \ 500 \ 501 index += (debug->__name.word_base / \ 502 debug->__name.word_size); \ 503 \ 504 if (debug->__name.flags & RT2X00DEBUGFS_OFFSET) \ 505 index *= debug->__name.word_size; \ 506 \ 507 debug->__name.write(intf->rt2x00dev, index, value); \ 508 \ 509 *offset += size; \ 510 return size; \ 511 } 512 513 #define RT2X00DEBUGFS_OPS(__name, __format, __type) \ 514 RT2X00DEBUGFS_OPS_READ(__name, __format, __type); \ 515 RT2X00DEBUGFS_OPS_WRITE(__name, __type); \ 516 \ 517 static const struct file_operations rt2x00debug_fop_##__name = {\ 518 .owner = THIS_MODULE, \ 519 .read = rt2x00debug_read_##__name, \ 520 .write = rt2x00debug_write_##__name, \ 521 .open = rt2x00debug_file_open, \ 522 .release = rt2x00debug_file_release, \ 523 .llseek = generic_file_llseek, \ 524 }; 525 526 RT2X00DEBUGFS_OPS(csr, "0x%.8x\n", u32); 527 RT2X00DEBUGFS_OPS(eeprom, "0x%.4x\n", u16); 528 RT2X00DEBUGFS_OPS(bbp, "0x%.2x\n", u8); 529 RT2X00DEBUGFS_OPS(rf, "0x%.8x\n", u32); 530 RT2X00DEBUGFS_OPS(rfcsr, "0x%.2x\n", u8); 531 532 static ssize_t rt2x00debug_read_dev_flags(struct file *file, 533 char __user *buf, 534 size_t length, 535 loff_t *offset) 536 { 537 struct rt2x00debug_intf *intf = file->private_data; 538 char line[16]; 539 size_t size; 540 541 if (*offset) 542 return 0; 543 544 size = sprintf(line, "0x%.8x\n", (unsigned int)intf->rt2x00dev->flags); 545 546 if (copy_to_user(buf, line, size)) 547 return -EFAULT; 548 549 *offset += size; 550 return size; 551 } 552 553 static const struct file_operations rt2x00debug_fop_dev_flags = { 554 .owner = THIS_MODULE, 555 .read = rt2x00debug_read_dev_flags, 556 .open = rt2x00debug_file_open, 557 .release = rt2x00debug_file_release, 558 .llseek = default_llseek, 559 }; 560 561 static ssize_t rt2x00debug_read_cap_flags(struct file *file, 562 char __user *buf, 563 size_t length, 564 loff_t *offset) 565 { 566 struct rt2x00debug_intf *intf = file->private_data; 567 char line[16]; 568 size_t size; 569 570 if (*offset) 571 return 0; 572 573 size = sprintf(line, "0x%.8x\n", (unsigned int)intf->rt2x00dev->cap_flags); 574 575 if (copy_to_user(buf, line, size)) 576 return -EFAULT; 577 578 *offset += size; 579 return size; 580 } 581 582 static const struct file_operations rt2x00debug_fop_cap_flags = { 583 .owner = THIS_MODULE, 584 .read = rt2x00debug_read_cap_flags, 585 .open = rt2x00debug_file_open, 586 .release = rt2x00debug_file_release, 587 .llseek = default_llseek, 588 }; 589 590 static struct dentry *rt2x00debug_create_file_driver(const char *name, 591 struct rt2x00debug_intf 592 *intf, 593 struct debugfs_blob_wrapper 594 *blob) 595 { 596 char *data; 597 598 data = kzalloc(3 * MAX_LINE_LENGTH, GFP_KERNEL); 599 if (!data) 600 return NULL; 601 602 blob->data = data; 603 data += sprintf(data, "driver:\t%s\n", intf->rt2x00dev->ops->name); 604 data += sprintf(data, "version:\t%s\n", DRV_VERSION); 605 blob->size = strlen(blob->data); 606 607 return debugfs_create_blob(name, S_IRUSR, intf->driver_folder, blob); 608 } 609 610 static struct dentry *rt2x00debug_create_file_chipset(const char *name, 611 struct rt2x00debug_intf 612 *intf, 613 struct 614 debugfs_blob_wrapper 615 *blob) 616 { 617 const struct rt2x00debug *debug = intf->debug; 618 char *data; 619 620 data = kzalloc(9 * MAX_LINE_LENGTH, GFP_KERNEL); 621 if (!data) 622 return NULL; 623 624 blob->data = data; 625 data += sprintf(data, "rt chip:\t%04x\n", intf->rt2x00dev->chip.rt); 626 data += sprintf(data, "rf chip:\t%04x\n", intf->rt2x00dev->chip.rf); 627 data += sprintf(data, "revision:\t%04x\n", intf->rt2x00dev->chip.rev); 628 data += sprintf(data, "\n"); 629 data += sprintf(data, "register\tbase\twords\twordsize\n"); 630 #define RT2X00DEBUGFS_SPRINTF_REGISTER(__name) \ 631 { \ 632 if(debug->__name.read) \ 633 data += sprintf(data, __stringify(__name) \ 634 "\t%d\t%d\t%d\n", \ 635 debug->__name.word_base, \ 636 debug->__name.word_count, \ 637 debug->__name.word_size); \ 638 } 639 RT2X00DEBUGFS_SPRINTF_REGISTER(csr); 640 RT2X00DEBUGFS_SPRINTF_REGISTER(eeprom); 641 RT2X00DEBUGFS_SPRINTF_REGISTER(bbp); 642 RT2X00DEBUGFS_SPRINTF_REGISTER(rf); 643 RT2X00DEBUGFS_SPRINTF_REGISTER(rfcsr); 644 #undef RT2X00DEBUGFS_SPRINTF_REGISTER 645 646 blob->size = strlen(blob->data); 647 648 return debugfs_create_blob(name, S_IRUSR, intf->driver_folder, blob); 649 } 650 651 void rt2x00debug_register(struct rt2x00_dev *rt2x00dev) 652 { 653 const struct rt2x00debug *debug = rt2x00dev->ops->debugfs; 654 struct rt2x00debug_intf *intf; 655 656 intf = kzalloc(sizeof(struct rt2x00debug_intf), GFP_KERNEL); 657 if (!intf) { 658 rt2x00_err(rt2x00dev, "Failed to allocate debug handler\n"); 659 return; 660 } 661 662 intf->debug = debug; 663 intf->rt2x00dev = rt2x00dev; 664 rt2x00dev->debugfs_intf = intf; 665 666 intf->driver_folder = 667 debugfs_create_dir(intf->rt2x00dev->ops->name, 668 rt2x00dev->hw->wiphy->debugfsdir); 669 if (IS_ERR(intf->driver_folder) || !intf->driver_folder) 670 goto exit; 671 672 intf->driver_entry = 673 rt2x00debug_create_file_driver("driver", intf, &intf->driver_blob); 674 if (IS_ERR(intf->driver_entry) || !intf->driver_entry) 675 goto exit; 676 677 intf->chipset_entry = 678 rt2x00debug_create_file_chipset("chipset", 679 intf, &intf->chipset_blob); 680 if (IS_ERR(intf->chipset_entry) || !intf->chipset_entry) 681 goto exit; 682 683 intf->dev_flags = debugfs_create_file("dev_flags", S_IRUSR, 684 intf->driver_folder, intf, 685 &rt2x00debug_fop_dev_flags); 686 if (IS_ERR(intf->dev_flags) || !intf->dev_flags) 687 goto exit; 688 689 intf->cap_flags = debugfs_create_file("cap_flags", S_IRUSR, 690 intf->driver_folder, intf, 691 &rt2x00debug_fop_cap_flags); 692 if (IS_ERR(intf->cap_flags) || !intf->cap_flags) 693 goto exit; 694 695 intf->register_folder = 696 debugfs_create_dir("register", intf->driver_folder); 697 if (IS_ERR(intf->register_folder) || !intf->register_folder) 698 goto exit; 699 700 #define RT2X00DEBUGFS_CREATE_REGISTER_ENTRY(__intf, __name) \ 701 ({ \ 702 if(debug->__name.read) { \ 703 (__intf)->__name##_off_entry = \ 704 debugfs_create_u32(__stringify(__name) "_offset", \ 705 S_IRUSR | S_IWUSR, \ 706 (__intf)->register_folder, \ 707 &(__intf)->offset_##__name); \ 708 if (IS_ERR((__intf)->__name##_off_entry) \ 709 || !(__intf)->__name##_off_entry) \ 710 goto exit; \ 711 \ 712 (__intf)->__name##_val_entry = \ 713 debugfs_create_file(__stringify(__name) "_value", \ 714 S_IRUSR | S_IWUSR, \ 715 (__intf)->register_folder, \ 716 (__intf), &rt2x00debug_fop_##__name); \ 717 if (IS_ERR((__intf)->__name##_val_entry) \ 718 || !(__intf)->__name##_val_entry) \ 719 goto exit; \ 720 } \ 721 }) 722 723 RT2X00DEBUGFS_CREATE_REGISTER_ENTRY(intf, csr); 724 RT2X00DEBUGFS_CREATE_REGISTER_ENTRY(intf, eeprom); 725 RT2X00DEBUGFS_CREATE_REGISTER_ENTRY(intf, bbp); 726 RT2X00DEBUGFS_CREATE_REGISTER_ENTRY(intf, rf); 727 RT2X00DEBUGFS_CREATE_REGISTER_ENTRY(intf, rfcsr); 728 729 #undef RT2X00DEBUGFS_CREATE_REGISTER_ENTRY 730 731 intf->queue_folder = 732 debugfs_create_dir("queue", intf->driver_folder); 733 if (IS_ERR(intf->queue_folder) || !intf->queue_folder) 734 goto exit; 735 736 intf->queue_frame_dump_entry = 737 debugfs_create_file("dump", S_IRUSR, intf->queue_folder, 738 intf, &rt2x00debug_fop_queue_dump); 739 if (IS_ERR(intf->queue_frame_dump_entry) 740 || !intf->queue_frame_dump_entry) 741 goto exit; 742 743 skb_queue_head_init(&intf->frame_dump_skbqueue); 744 init_waitqueue_head(&intf->frame_dump_waitqueue); 745 746 intf->queue_stats_entry = 747 debugfs_create_file("queue", S_IRUSR, intf->queue_folder, 748 intf, &rt2x00debug_fop_queue_stats); 749 750 #ifdef CONFIG_RT2X00_LIB_CRYPTO 751 if (rt2x00_has_cap_hw_crypto(rt2x00dev)) 752 intf->crypto_stats_entry = 753 debugfs_create_file("crypto", S_IRUGO, intf->queue_folder, 754 intf, &rt2x00debug_fop_crypto_stats); 755 #endif 756 757 return; 758 759 exit: 760 rt2x00debug_deregister(rt2x00dev); 761 rt2x00_err(rt2x00dev, "Failed to register debug handler\n"); 762 } 763 764 void rt2x00debug_deregister(struct rt2x00_dev *rt2x00dev) 765 { 766 struct rt2x00debug_intf *intf = rt2x00dev->debugfs_intf; 767 768 if (unlikely(!intf)) 769 return; 770 771 skb_queue_purge(&intf->frame_dump_skbqueue); 772 773 #ifdef CONFIG_RT2X00_LIB_CRYPTO 774 debugfs_remove(intf->crypto_stats_entry); 775 #endif 776 debugfs_remove(intf->queue_stats_entry); 777 debugfs_remove(intf->queue_frame_dump_entry); 778 debugfs_remove(intf->queue_folder); 779 debugfs_remove(intf->rfcsr_val_entry); 780 debugfs_remove(intf->rfcsr_off_entry); 781 debugfs_remove(intf->rf_val_entry); 782 debugfs_remove(intf->rf_off_entry); 783 debugfs_remove(intf->bbp_val_entry); 784 debugfs_remove(intf->bbp_off_entry); 785 debugfs_remove(intf->eeprom_val_entry); 786 debugfs_remove(intf->eeprom_off_entry); 787 debugfs_remove(intf->csr_val_entry); 788 debugfs_remove(intf->csr_off_entry); 789 debugfs_remove(intf->register_folder); 790 debugfs_remove(intf->dev_flags); 791 debugfs_remove(intf->cap_flags); 792 debugfs_remove(intf->chipset_entry); 793 debugfs_remove(intf->driver_entry); 794 debugfs_remove(intf->driver_folder); 795 kfree(intf->chipset_blob.data); 796 kfree(intf->driver_blob.data); 797 kfree(intf); 798 799 rt2x00dev->debugfs_intf = NULL; 800 } 801