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 28struct whc_dbg { 29 struct dentry *di_f; 30 struct dentry *asl_f; 31 struct dentry *pzl_f; 32}; 33 34static 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 86static 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 109static 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 121static 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 136static int di_open(struct inode *inode, struct file *file) 137{ 138 return single_open(file, di_print, inode->i_private); 139} 140 141static int asl_open(struct inode *inode, struct file *file) 142{ 143 return single_open(file, asl_print, inode->i_private); 144} 145 146static int pzl_open(struct inode *inode, struct file *file) 147{ 148 return single_open(file, pzl_print, inode->i_private); 149} 150 151static 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 159static 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 167static 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 175void 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 195void 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