drivers/usb/host/whci/debug.c

   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
  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
  86 static int di_print(struct seq_file *s, void *p)
  87 {
  88         struct whc *whc = s->private;
  89         int d;
  90
  91         for (d = 0; d < whc->n_devices; d++) {
  92                 struct di_buf_entry *di = &whc->di_buf[d];
  93
  94                 seq_printf(s, "DI[%d]\n", d);
  95                 seq_printf(s, "  availability: %*pb\n",
  96                            UWB_NUM_MAS, (unsigned long *)di->availability_info);
  97                 seq_printf(s, "  %c%c key idx: %d dev addr: %d\n",
  98                            (di->addr_sec_info & WHC_DI_SECURE) ? 'S' : ' ',
  99                            (di->addr_sec_info & WHC_DI_DISABLE) ? 'D' : ' ',
 100                            (di->addr_sec_info & WHC_DI_KEY_IDX_MASK) >> 8,
 101                            (di->addr_sec_info & WHC_DI_DEV_ADDR_MASK));
 102         }
 103         return 0;
 104 }
 105
 106 static int asl_print(struct seq_file *s, void *p)
 107 {
 108         struct whc *whc = s->private;
 109         struct whc_qset *qset;
 110
 111         list_for_each_entry(qset, &whc->async_list, list_node) {
 112                 qset_print(s, qset);
 113         }
 114
 115         return 0;
 116 }
 117
 118 static int pzl_print(struct seq_file *s, void *p)
 119 {
 120         struct whc *whc = s->private;
 121         struct whc_qset *qset;
 122         int period;
 123
 124         for (period = 0; period < 5; period++) {
 125                 seq_printf(s, "Period %d\n", period);
 126                 list_for_each_entry(qset, &whc->periodic_list[period], list_node) {
 127                         qset_print(s, qset);
 128                 }
 129         }
 130         return 0;
 131 }
 132
 133 static int di_open(struct inode *inode, struct file *file)
 134 {
 135         return single_open(file, di_print, inode->i_private);
 136 }
 137
 138 static int asl_open(struct inode *inode, struct file *file)
 139 {
 140         return single_open(file, asl_print, inode->i_private);
 141 }
 142
 143 static int pzl_open(struct inode *inode, struct file *file)
 144 {
 145         return single_open(file, pzl_print, inode->i_private);
 146 }
 147
 148 static const struct file_operations di_fops = {
 149         .open    = di_open,
 150         .read    = seq_read,
 151         .llseek  = seq_lseek,
 152         .release = single_release,
 153         .owner   = THIS_MODULE,
 154 };
 155
 156 static const struct file_operations asl_fops = {
 157         .open    = asl_open,
 158         .read    = seq_read,
 159         .llseek  = seq_lseek,
 160         .release = single_release,
 161         .owner   = THIS_MODULE,
 162 };
 163
 164 static const struct file_operations pzl_fops = {
 165         .open    = pzl_open,
 166         .read    = seq_read,
 167         .llseek  = seq_lseek,
 168         .release = single_release,
 169         .owner   = THIS_MODULE,
 170 };
 171
 172 void whc_dbg_init(struct whc *whc)
 173 {
 174         if (whc->wusbhc.pal.debugfs_dir == NULL)
 175                 return;
 176
 177         whc->dbg = kzalloc(sizeof(struct whc_dbg), GFP_KERNEL);
 178         if (whc->dbg == NULL)
 179                 return;
 180
 181         whc->dbg->di_f = debugfs_create_file("di", 0444,
 182                                               whc->wusbhc.pal.debugfs_dir, whc,
 183                                               &di_fops);
 184         whc->dbg->asl_f = debugfs_create_file("asl", 0444,
 185                                               whc->wusbhc.pal.debugfs_dir, whc,
 186                                               &asl_fops);
 187         whc->dbg->pzl_f = debugfs_create_file("pzl", 0444,
 188                                               whc->wusbhc.pal.debugfs_dir, whc,
 189                                               &pzl_fops);
 190 }
 191
 192 void whc_dbg_clean_up(struct whc *whc)
 193 {
 194         if (whc->dbg) {
 195                 debugfs_remove(whc->dbg->pzl_f);
 196                 debugfs_remove(whc->dbg->asl_f);
 197                 debugfs_remove(whc->dbg->di_f);
 198                 kfree(whc->dbg);
 199         }
 200 }