1 /*
2 * Wireless Host Controller (WHC) debug.
3 *
4 * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License version
8 * 2 as published by the Free Software Foundation.
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 #include <linux/slab.h>
19 #include <linux/kernel.h>
20 #include <linux/debugfs.h>
21 #include <linux/seq_file.h>
22 #include <linux/export.h>
23
24 #include "../../wusbcore/wusbhc.h"
25
26 #include "whcd.h"
27
28 struct whc_dbg {
29 struct dentry *di_f;
30 struct dentry *asl_f;
31 struct dentry *pzl_f;
32 };
33
qset_print(struct seq_file * s,struct whc_qset * qset)34 static void qset_print(struct seq_file *s, struct whc_qset *qset)
35 {
36 static const char *qh_type[] = {
37 "ctrl", "isoc", "bulk", "intr", "rsvd", "rsvd", "rsvd", "lpintr", };
38 struct whc_std *std;
39 struct urb *urb = NULL;
40 int i;
41
42 seq_printf(s, "qset %08x", (u32)qset->qset_dma);
43 if (&qset->list_node == qset->whc->async_list.prev) {
44 seq_printf(s, " (dummy)\n");
45 } else {
46 seq_printf(s, " ep%d%s-%s maxpkt: %d\n",
47 qset->qh.info1 & 0x0f,
48 (qset->qh.info1 >> 4) & 0x1 ? "in" : "out",
49 qh_type[(qset->qh.info1 >> 5) & 0x7],
50 (qset->qh.info1 >> 16) & 0xffff);
51 }
52 seq_printf(s, " -> %08x\n", (u32)qset->qh.link);
53 seq_printf(s, " info: %08x %08x %08x\n",
54 qset->qh.info1, qset->qh.info2, qset->qh.info3);
55 seq_printf(s, " sts: %04x errs: %d curwin: %08x\n",
56 qset->qh.status, qset->qh.err_count, qset->qh.cur_window);
57 seq_printf(s, " TD: sts: %08x opts: %08x\n",
58 qset->qh.overlay.qtd.status, qset->qh.overlay.qtd.options);
59
60 for (i = 0; i < WHCI_QSET_TD_MAX; i++) {
61 seq_printf(s, " %c%c TD[%d]: sts: %08x opts: %08x ptr: %08x\n",
62 i == qset->td_start ? 'S' : ' ',
63 i == qset->td_end ? 'E' : ' ',
64 i, qset->qtd[i].status, qset->qtd[i].options,
65 (u32)qset->qtd[i].page_list_ptr);
66 }
67 seq_printf(s, " ntds: %d\n", qset->ntds);
68 list_for_each_entry(std, &qset->stds, list_node) {
69 if (urb != std->urb) {
70 urb = std->urb;
71 seq_printf(s, " urb %p transferred: %d bytes\n", urb,
72 urb->actual_length);
73 }
74 if (std->qtd)
75 seq_printf(s, " sTD[%td]: %zu bytes @ %08x\n",
76 std->qtd - &qset->qtd[0],
77 std->len, std->num_pointers ?
78 (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
79 else
80 seq_printf(s, " sTD[-]: %zd bytes @ %08x\n",
81 std->len, std->num_pointers ?
82 (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
83 }
84 }
85
di_print(struct seq_file * s,void * p)86 static int di_print(struct seq_file *s, void *p)
87 {
88 struct whc *whc = s->private;
89 char buf[72];
90 int d;
91
92 for (d = 0; d < whc->n_devices; d++) {
93 struct di_buf_entry *di = &whc->di_buf[d];
94
95 bitmap_scnprintf(buf, sizeof(buf),
96 (unsigned long *)di->availability_info, UWB_NUM_MAS);
97
98 seq_printf(s, "DI[%d]\n", d);
99 seq_printf(s, " availability: %s\n", buf);
100 seq_printf(s, " %c%c key idx: %d dev addr: %d\n",
101 (di->addr_sec_info & WHC_DI_SECURE) ? 'S' : ' ',
102 (di->addr_sec_info & WHC_DI_DISABLE) ? 'D' : ' ',
103 (di->addr_sec_info & WHC_DI_KEY_IDX_MASK) >> 8,
104 (di->addr_sec_info & WHC_DI_DEV_ADDR_MASK));
105 }
106 return 0;
107 }
108
asl_print(struct seq_file * s,void * p)109 static int asl_print(struct seq_file *s, void *p)
110 {
111 struct whc *whc = s->private;
112 struct whc_qset *qset;
113
114 list_for_each_entry(qset, &whc->async_list, list_node) {
115 qset_print(s, qset);
116 }
117
118 return 0;
119 }
120
pzl_print(struct seq_file * s,void * p)121 static int pzl_print(struct seq_file *s, void *p)
122 {
123 struct whc *whc = s->private;
124 struct whc_qset *qset;
125 int period;
126
127 for (period = 0; period < 5; period++) {
128 seq_printf(s, "Period %d\n", period);
129 list_for_each_entry(qset, &whc->periodic_list[period], list_node) {
130 qset_print(s, qset);
131 }
132 }
133 return 0;
134 }
135
di_open(struct inode * inode,struct file * file)136 static int di_open(struct inode *inode, struct file *file)
137 {
138 return single_open(file, di_print, inode->i_private);
139 }
140
asl_open(struct inode * inode,struct file * file)141 static int asl_open(struct inode *inode, struct file *file)
142 {
143 return single_open(file, asl_print, inode->i_private);
144 }
145
pzl_open(struct inode * inode,struct file * file)146 static int pzl_open(struct inode *inode, struct file *file)
147 {
148 return single_open(file, pzl_print, inode->i_private);
149 }
150
151 static const struct file_operations di_fops = {
152 .open = di_open,
153 .read = seq_read,
154 .llseek = seq_lseek,
155 .release = single_release,
156 .owner = THIS_MODULE,
157 };
158
159 static const struct file_operations asl_fops = {
160 .open = asl_open,
161 .read = seq_read,
162 .llseek = seq_lseek,
163 .release = single_release,
164 .owner = THIS_MODULE,
165 };
166
167 static const struct file_operations pzl_fops = {
168 .open = pzl_open,
169 .read = seq_read,
170 .llseek = seq_lseek,
171 .release = single_release,
172 .owner = THIS_MODULE,
173 };
174
whc_dbg_init(struct whc * whc)175 void whc_dbg_init(struct whc *whc)
176 {
177 if (whc->wusbhc.pal.debugfs_dir == NULL)
178 return;
179
180 whc->dbg = kzalloc(sizeof(struct whc_dbg), GFP_KERNEL);
181 if (whc->dbg == NULL)
182 return;
183
184 whc->dbg->di_f = debugfs_create_file("di", 0444,
185 whc->wusbhc.pal.debugfs_dir, whc,
186 &di_fops);
187 whc->dbg->asl_f = debugfs_create_file("asl", 0444,
188 whc->wusbhc.pal.debugfs_dir, whc,
189 &asl_fops);
190 whc->dbg->pzl_f = debugfs_create_file("pzl", 0444,
191 whc->wusbhc.pal.debugfs_dir, whc,
192 &pzl_fops);
193 }
194
whc_dbg_clean_up(struct whc * whc)195 void whc_dbg_clean_up(struct whc *whc)
196 {
197 if (whc->dbg) {
198 debugfs_remove(whc->dbg->pzl_f);
199 debugfs_remove(whc->dbg->asl_f);
200 debugfs_remove(whc->dbg->di_f);
201 kfree(whc->dbg);
202 }
203 }
204