2 Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
3 <http://rt2x00.serialmonkey.com>
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.
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.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the
17 Free Software Foundation, Inc.,
18 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23 Abstract: rt2x00 debugfs specific routines.
26 #include <linux/debugfs.h>
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/poll.h>
30 #include <linux/uaccess.h>
33 #include "rt2x00lib.h"
34 #include "rt2x00dump.h"
36 #define MAX_LINE_LENGTH 64
38 struct rt2x00debug_crypto
{
39 unsigned long success
;
40 unsigned long icv_error
;
41 unsigned long mic_error
;
42 unsigned long key_error
;
45 struct rt2x00debug_intf
{
47 * Pointer to driver structure where
48 * this debugfs entry belongs to.
50 struct rt2x00_dev
*rt2x00dev
;
53 * Reference to the rt2x00debug structure
54 * which can be used to communicate with
57 const struct rt2x00debug
*debug
;
60 * Debugfs entries for:
66 * - csr offset/value files
67 * - eeprom offset/value files
68 * - bbp offset/value files
69 * - rf offset/value files
75 struct dentry
*driver_folder
;
76 struct dentry
*driver_entry
;
77 struct dentry
*chipset_entry
;
78 struct dentry
*dev_flags
;
79 struct dentry
*register_folder
;
80 struct dentry
*csr_off_entry
;
81 struct dentry
*csr_val_entry
;
82 struct dentry
*eeprom_off_entry
;
83 struct dentry
*eeprom_val_entry
;
84 struct dentry
*bbp_off_entry
;
85 struct dentry
*bbp_val_entry
;
86 struct dentry
*rf_off_entry
;
87 struct dentry
*rf_val_entry
;
88 struct dentry
*queue_folder
;
89 struct dentry
*queue_frame_dump_entry
;
90 struct dentry
*queue_stats_entry
;
91 struct dentry
*crypto_stats_entry
;
94 * The frame dump file only allows a single reader,
95 * so we need to store the current state here.
97 unsigned long frame_dump_flags
;
98 #define FRAME_DUMP_FILE_OPEN 1
101 * We queue each frame before dumping it to the user,
102 * per read command we will pass a single skb structure
103 * so we should be prepared to queue multiple sk buffers
104 * before sending it to userspace.
106 struct sk_buff_head frame_dump_skbqueue
;
107 wait_queue_head_t frame_dump_waitqueue
;
110 * HW crypto statistics.
111 * All statistics are stored seperately per cipher type.
113 struct rt2x00debug_crypto crypto_stats
[CIPHER_MAX
];
116 * Driver and chipset files will use a data buffer
117 * that has been created in advance. This will simplify
118 * the code since we can use the debugfs functions.
120 struct debugfs_blob_wrapper driver_blob
;
121 struct debugfs_blob_wrapper chipset_blob
;
124 * Requested offset for each register type.
126 unsigned int offset_csr
;
127 unsigned int offset_eeprom
;
128 unsigned int offset_bbp
;
129 unsigned int offset_rf
;
132 void rt2x00debug_update_crypto(struct rt2x00_dev
*rt2x00dev
,
133 enum cipher cipher
, enum rx_crypto status
)
135 struct rt2x00debug_intf
*intf
= rt2x00dev
->debugfs_intf
;
137 if (cipher
== CIPHER_TKIP_NO_MIC
)
138 cipher
= CIPHER_TKIP
;
139 if (cipher
== CIPHER_NONE
|| cipher
> CIPHER_MAX
)
142 /* Remove CIPHER_NONE index */
145 intf
->crypto_stats
[cipher
].success
+= (status
== RX_CRYPTO_SUCCESS
);
146 intf
->crypto_stats
[cipher
].icv_error
+= (status
== RX_CRYPTO_FAIL_ICV
);
147 intf
->crypto_stats
[cipher
].mic_error
+= (status
== RX_CRYPTO_FAIL_MIC
);
148 intf
->crypto_stats
[cipher
].key_error
+= (status
== RX_CRYPTO_FAIL_KEY
);
151 void rt2x00debug_dump_frame(struct rt2x00_dev
*rt2x00dev
,
152 enum rt2x00_dump_type type
, struct sk_buff
*skb
)
154 struct rt2x00debug_intf
*intf
= rt2x00dev
->debugfs_intf
;
155 struct skb_frame_desc
*desc
= get_skb_frame_desc(skb
);
156 struct sk_buff
*skbcopy
;
157 struct rt2x00dump_hdr
*dump_hdr
;
158 struct timeval timestamp
;
160 do_gettimeofday(×tamp
);
162 if (!test_bit(FRAME_DUMP_FILE_OPEN
, &intf
->frame_dump_flags
))
165 if (skb_queue_len(&intf
->frame_dump_skbqueue
) > 20) {
166 DEBUG(rt2x00dev
, "txrx dump queue length exceeded.\n");
170 skbcopy
= alloc_skb(sizeof(*dump_hdr
) + desc
->desc_len
+ skb
->len
,
173 DEBUG(rt2x00dev
, "Failed to copy skb for dump.\n");
177 dump_hdr
= (struct rt2x00dump_hdr
*)skb_put(skbcopy
, sizeof(*dump_hdr
));
178 dump_hdr
->version
= cpu_to_le32(DUMP_HEADER_VERSION
);
179 dump_hdr
->header_length
= cpu_to_le32(sizeof(*dump_hdr
));
180 dump_hdr
->desc_length
= cpu_to_le32(desc
->desc_len
);
181 dump_hdr
->data_length
= cpu_to_le32(skb
->len
);
182 dump_hdr
->chip_rt
= cpu_to_le16(rt2x00dev
->chip
.rt
);
183 dump_hdr
->chip_rf
= cpu_to_le16(rt2x00dev
->chip
.rf
);
184 dump_hdr
->chip_rev
= cpu_to_le32(rt2x00dev
->chip
.rev
);
185 dump_hdr
->type
= cpu_to_le16(type
);
186 dump_hdr
->queue_index
= desc
->entry
->queue
->qid
;
187 dump_hdr
->entry_index
= desc
->entry
->entry_idx
;
188 dump_hdr
->timestamp_sec
= cpu_to_le32(timestamp
.tv_sec
);
189 dump_hdr
->timestamp_usec
= cpu_to_le32(timestamp
.tv_usec
);
191 memcpy(skb_put(skbcopy
, desc
->desc_len
), desc
->desc
, desc
->desc_len
);
192 memcpy(skb_put(skbcopy
, skb
->len
), skb
->data
, skb
->len
);
194 skb_queue_tail(&intf
->frame_dump_skbqueue
, skbcopy
);
195 wake_up_interruptible(&intf
->frame_dump_waitqueue
);
198 * Verify that the file has not been closed while we were working.
200 if (!test_bit(FRAME_DUMP_FILE_OPEN
, &intf
->frame_dump_flags
))
201 skb_queue_purge(&intf
->frame_dump_skbqueue
);
204 static int rt2x00debug_file_open(struct inode
*inode
, struct file
*file
)
206 struct rt2x00debug_intf
*intf
= inode
->i_private
;
208 file
->private_data
= inode
->i_private
;
210 if (!try_module_get(intf
->debug
->owner
))
216 static int rt2x00debug_file_release(struct inode
*inode
, struct file
*file
)
218 struct rt2x00debug_intf
*intf
= file
->private_data
;
220 module_put(intf
->debug
->owner
);
225 static int rt2x00debug_open_queue_dump(struct inode
*inode
, struct file
*file
)
227 struct rt2x00debug_intf
*intf
= inode
->i_private
;
230 retval
= rt2x00debug_file_open(inode
, file
);
234 if (test_and_set_bit(FRAME_DUMP_FILE_OPEN
, &intf
->frame_dump_flags
)) {
235 rt2x00debug_file_release(inode
, file
);
242 static int rt2x00debug_release_queue_dump(struct inode
*inode
, struct file
*file
)
244 struct rt2x00debug_intf
*intf
= inode
->i_private
;
246 skb_queue_purge(&intf
->frame_dump_skbqueue
);
248 clear_bit(FRAME_DUMP_FILE_OPEN
, &intf
->frame_dump_flags
);
250 return rt2x00debug_file_release(inode
, file
);
253 static ssize_t
rt2x00debug_read_queue_dump(struct file
*file
,
258 struct rt2x00debug_intf
*intf
= file
->private_data
;
263 if (file
->f_flags
& O_NONBLOCK
)
267 wait_event_interruptible(intf
->frame_dump_waitqueue
,
269 skb_dequeue(&intf
->frame_dump_skbqueue
)));
273 status
= min((size_t)skb
->len
, length
);
274 if (copy_to_user(buf
, skb
->data
, status
)) {
287 static unsigned int rt2x00debug_poll_queue_dump(struct file
*file
,
290 struct rt2x00debug_intf
*intf
= file
->private_data
;
292 poll_wait(file
, &intf
->frame_dump_waitqueue
, wait
);
294 if (!skb_queue_empty(&intf
->frame_dump_skbqueue
))
295 return POLLOUT
| POLLWRNORM
;
300 static const struct file_operations rt2x00debug_fop_queue_dump
= {
301 .owner
= THIS_MODULE
,
302 .read
= rt2x00debug_read_queue_dump
,
303 .poll
= rt2x00debug_poll_queue_dump
,
304 .open
= rt2x00debug_open_queue_dump
,
305 .release
= rt2x00debug_release_queue_dump
,
308 static ssize_t
rt2x00debug_read_queue_stats(struct file
*file
,
313 struct rt2x00debug_intf
*intf
= file
->private_data
;
314 struct data_queue
*queue
;
315 unsigned long irqflags
;
316 unsigned int lines
= 1 + intf
->rt2x00dev
->data_queues
;
324 data
= kzalloc(lines
* MAX_LINE_LENGTH
, GFP_KERNEL
);
329 sprintf(data
, "qid\tcount\tlimit\tlength\tindex\tdone\tcrypto\n");
331 queue_for_each(intf
->rt2x00dev
, queue
) {
332 spin_lock_irqsave(&queue
->lock
, irqflags
);
334 temp
+= sprintf(temp
, "%d\t%d\t%d\t%d\t%d\t%d\t%d\n", queue
->qid
,
335 queue
->count
, queue
->limit
, queue
->length
,
336 queue
->index
[Q_INDEX
],
337 queue
->index
[Q_INDEX_DONE
],
338 queue
->index
[Q_INDEX_CRYPTO
]);
340 spin_unlock_irqrestore(&queue
->lock
, irqflags
);
344 size
= min(size
, length
);
346 if (copy_to_user(buf
, data
, size
)) {
357 static const struct file_operations rt2x00debug_fop_queue_stats
= {
358 .owner
= THIS_MODULE
,
359 .read
= rt2x00debug_read_queue_stats
,
360 .open
= rt2x00debug_file_open
,
361 .release
= rt2x00debug_file_release
,
364 #ifdef CONFIG_RT2X00_LIB_CRYPTO
365 static ssize_t
rt2x00debug_read_crypto_stats(struct file
*file
,
370 struct rt2x00debug_intf
*intf
= file
->private_data
;
371 char *name
[] = { "WEP64", "WEP128", "TKIP", "AES" };
380 data
= kzalloc((1 + CIPHER_MAX
) * MAX_LINE_LENGTH
, GFP_KERNEL
);
385 temp
+= sprintf(data
, "cipher\tsuccess\ticv err\tmic err\tkey err\n");
387 for (i
= 0; i
< CIPHER_MAX
; i
++) {
388 temp
+= sprintf(temp
, "%s\t%lu\t%lu\t%lu\t%lu\n", name
[i
],
389 intf
->crypto_stats
[i
].success
,
390 intf
->crypto_stats
[i
].icv_error
,
391 intf
->crypto_stats
[i
].mic_error
,
392 intf
->crypto_stats
[i
].key_error
);
396 size
= min(size
, length
);
398 if (copy_to_user(buf
, data
, size
)) {
409 static const struct file_operations rt2x00debug_fop_crypto_stats
= {
410 .owner
= THIS_MODULE
,
411 .read
= rt2x00debug_read_crypto_stats
,
412 .open
= rt2x00debug_file_open
,
413 .release
= rt2x00debug_file_release
,
417 #define RT2X00DEBUGFS_OPS_READ(__name, __format, __type) \
418 static ssize_t rt2x00debug_read_##__name(struct file *file, \
423 struct rt2x00debug_intf *intf = file->private_data; \
424 const struct rt2x00debug *debug = intf->debug; \
427 unsigned int index = intf->offset_##__name; \
433 if (index >= debug->__name.word_count) \
436 if (debug->__name.flags & RT2X00DEBUGFS_OFFSET) \
437 index *= debug->__name.word_size; \
439 index += debug->__name.word_base; \
441 debug->__name.read(intf->rt2x00dev, index, &value); \
443 size = sprintf(line, __format, value); \
445 if (copy_to_user(buf, line, size)) \
452 #define RT2X00DEBUGFS_OPS_WRITE(__name, __type) \
453 static ssize_t rt2x00debug_write_##__name(struct file *file, \
454 const char __user *buf,\
458 struct rt2x00debug_intf *intf = file->private_data; \
459 const struct rt2x00debug *debug = intf->debug; \
462 unsigned int index = intf->offset_##__name; \
468 if (index >= debug->__name.word_count) \
471 if (copy_from_user(line, buf, length)) \
474 size = strlen(line); \
475 value = simple_strtoul(line, NULL, 0); \
477 if (debug->__name.flags & RT2X00DEBUGFS_OFFSET) \
478 index *= debug->__name.word_size; \
480 index += debug->__name.word_base; \
482 debug->__name.write(intf->rt2x00dev, index, value); \
488 #define RT2X00DEBUGFS_OPS(__name, __format, __type) \
489 RT2X00DEBUGFS_OPS_READ(__name, __format, __type); \
490 RT2X00DEBUGFS_OPS_WRITE(__name, __type); \
492 static const struct file_operations rt2x00debug_fop_##__name = {\
493 .owner = THIS_MODULE, \
494 .read = rt2x00debug_read_##__name, \
495 .write = rt2x00debug_write_##__name, \
496 .open = rt2x00debug_file_open, \
497 .release = rt2x00debug_file_release, \
500 RT2X00DEBUGFS_OPS(csr
, "0x%.8x\n", u32
);
501 RT2X00DEBUGFS_OPS(eeprom
, "0x%.4x\n", u16
);
502 RT2X00DEBUGFS_OPS(bbp
, "0x%.2x\n", u8
);
503 RT2X00DEBUGFS_OPS(rf
, "0x%.8x\n", u32
);
505 static ssize_t
rt2x00debug_read_dev_flags(struct file
*file
,
510 struct rt2x00debug_intf
*intf
= file
->private_data
;
517 size
= sprintf(line
, "0x%.8x\n", (unsigned int)intf
->rt2x00dev
->flags
);
519 if (copy_to_user(buf
, line
, size
))
526 static const struct file_operations rt2x00debug_fop_dev_flags
= {
527 .owner
= THIS_MODULE
,
528 .read
= rt2x00debug_read_dev_flags
,
529 .open
= rt2x00debug_file_open
,
530 .release
= rt2x00debug_file_release
,
533 static struct dentry
*rt2x00debug_create_file_driver(const char *name
,
534 struct rt2x00debug_intf
536 struct debugfs_blob_wrapper
541 data
= kzalloc(3 * MAX_LINE_LENGTH
, GFP_KERNEL
);
546 data
+= sprintf(data
, "driver: %s\n", intf
->rt2x00dev
->ops
->name
);
547 data
+= sprintf(data
, "version: %s\n", DRV_VERSION
);
548 data
+= sprintf(data
, "compiled: %s %s\n", __DATE__
, __TIME__
);
549 blob
->size
= strlen(blob
->data
);
551 return debugfs_create_blob(name
, S_IRUSR
, intf
->driver_folder
, blob
);
554 static struct dentry
*rt2x00debug_create_file_chipset(const char *name
,
555 struct rt2x00debug_intf
561 const struct rt2x00debug
*debug
= intf
->debug
;
564 data
= kzalloc(8 * MAX_LINE_LENGTH
, GFP_KERNEL
);
569 data
+= sprintf(data
, "rt chip: %04x\n", intf
->rt2x00dev
->chip
.rt
);
570 data
+= sprintf(data
, "rf chip: %04x\n", intf
->rt2x00dev
->chip
.rf
);
571 data
+= sprintf(data
, "revision:%08x\n", intf
->rt2x00dev
->chip
.rev
);
572 data
+= sprintf(data
, "\n");
573 data
+= sprintf(data
, "csr length: %d\n", debug
->csr
.word_count
);
574 data
+= sprintf(data
, "eeprom length: %d\n", debug
->eeprom
.word_count
);
575 data
+= sprintf(data
, "bbp length: %d\n", debug
->bbp
.word_count
);
576 data
+= sprintf(data
, "rf length: %d\n", debug
->rf
.word_count
);
577 blob
->size
= strlen(blob
->data
);
579 return debugfs_create_blob(name
, S_IRUSR
, intf
->driver_folder
, blob
);
582 void rt2x00debug_register(struct rt2x00_dev
*rt2x00dev
)
584 const struct rt2x00debug
*debug
= rt2x00dev
->ops
->debugfs
;
585 struct rt2x00debug_intf
*intf
;
587 intf
= kzalloc(sizeof(struct rt2x00debug_intf
), GFP_KERNEL
);
589 ERROR(rt2x00dev
, "Failed to allocate debug handler.\n");
594 intf
->rt2x00dev
= rt2x00dev
;
595 rt2x00dev
->debugfs_intf
= intf
;
597 intf
->driver_folder
=
598 debugfs_create_dir(intf
->rt2x00dev
->ops
->name
,
599 rt2x00dev
->hw
->wiphy
->debugfsdir
);
600 if (IS_ERR(intf
->driver_folder
) || !intf
->driver_folder
)
604 rt2x00debug_create_file_driver("driver", intf
, &intf
->driver_blob
);
605 if (IS_ERR(intf
->driver_entry
) || !intf
->driver_entry
)
608 intf
->chipset_entry
=
609 rt2x00debug_create_file_chipset("chipset",
610 intf
, &intf
->chipset_blob
);
611 if (IS_ERR(intf
->chipset_entry
) || !intf
->chipset_entry
)
614 intf
->dev_flags
= debugfs_create_file("dev_flags", S_IRUSR
,
615 intf
->driver_folder
, intf
,
616 &rt2x00debug_fop_dev_flags
);
617 if (IS_ERR(intf
->dev_flags
) || !intf
->dev_flags
)
620 intf
->register_folder
=
621 debugfs_create_dir("register", intf
->driver_folder
);
622 if (IS_ERR(intf
->register_folder
) || !intf
->register_folder
)
625 #define RT2X00DEBUGFS_CREATE_REGISTER_ENTRY(__intf, __name) \
627 (__intf)->__name##_off_entry = \
628 debugfs_create_u32(__stringify(__name) "_offset", \
630 (__intf)->register_folder, \
631 &(__intf)->offset_##__name); \
632 if (IS_ERR((__intf)->__name##_off_entry) \
633 || !(__intf)->__name##_off_entry) \
636 (__intf)->__name##_val_entry = \
637 debugfs_create_file(__stringify(__name) "_value", \
639 (__intf)->register_folder, \
640 (__intf), &rt2x00debug_fop_##__name);\
641 if (IS_ERR((__intf)->__name##_val_entry) \
642 || !(__intf)->__name##_val_entry) \
646 RT2X00DEBUGFS_CREATE_REGISTER_ENTRY(intf
, csr
);
647 RT2X00DEBUGFS_CREATE_REGISTER_ENTRY(intf
, eeprom
);
648 RT2X00DEBUGFS_CREATE_REGISTER_ENTRY(intf
, bbp
);
649 RT2X00DEBUGFS_CREATE_REGISTER_ENTRY(intf
, rf
);
651 #undef RT2X00DEBUGFS_CREATE_REGISTER_ENTRY
654 debugfs_create_dir("queue", intf
->driver_folder
);
655 if (IS_ERR(intf
->queue_folder
) || !intf
->queue_folder
)
658 intf
->queue_frame_dump_entry
=
659 debugfs_create_file("dump", S_IRUSR
, intf
->queue_folder
,
660 intf
, &rt2x00debug_fop_queue_dump
);
661 if (IS_ERR(intf
->queue_frame_dump_entry
)
662 || !intf
->queue_frame_dump_entry
)
665 skb_queue_head_init(&intf
->frame_dump_skbqueue
);
666 init_waitqueue_head(&intf
->frame_dump_waitqueue
);
668 intf
->queue_stats_entry
=
669 debugfs_create_file("queue", S_IRUSR
, intf
->queue_folder
,
670 intf
, &rt2x00debug_fop_queue_stats
);
672 #ifdef CONFIG_RT2X00_LIB_CRYPTO
673 if (test_bit(CONFIG_SUPPORT_HW_CRYPTO
, &rt2x00dev
->flags
))
674 intf
->crypto_stats_entry
=
675 debugfs_create_file("crypto", S_IRUGO
, intf
->queue_folder
,
676 intf
, &rt2x00debug_fop_crypto_stats
);
682 rt2x00debug_deregister(rt2x00dev
);
683 ERROR(rt2x00dev
, "Failed to register debug handler.\n");
688 void rt2x00debug_deregister(struct rt2x00_dev
*rt2x00dev
)
690 struct rt2x00debug_intf
*intf
= rt2x00dev
->debugfs_intf
;
695 skb_queue_purge(&intf
->frame_dump_skbqueue
);
697 #ifdef CONFIG_RT2X00_LIB_CRYPTO
698 debugfs_remove(intf
->crypto_stats_entry
);
700 debugfs_remove(intf
->queue_stats_entry
);
701 debugfs_remove(intf
->queue_frame_dump_entry
);
702 debugfs_remove(intf
->queue_folder
);
703 debugfs_remove(intf
->rf_val_entry
);
704 debugfs_remove(intf
->rf_off_entry
);
705 debugfs_remove(intf
->bbp_val_entry
);
706 debugfs_remove(intf
->bbp_off_entry
);
707 debugfs_remove(intf
->eeprom_val_entry
);
708 debugfs_remove(intf
->eeprom_off_entry
);
709 debugfs_remove(intf
->csr_val_entry
);
710 debugfs_remove(intf
->csr_off_entry
);
711 debugfs_remove(intf
->register_folder
);
712 debugfs_remove(intf
->dev_flags
);
713 debugfs_remove(intf
->chipset_entry
);
714 debugfs_remove(intf
->driver_entry
);
715 debugfs_remove(intf
->driver_folder
);
716 kfree(intf
->chipset_blob
.data
);
717 kfree(intf
->driver_blob
.data
);
720 rt2x00dev
->debugfs_intf
= NULL
;