drivers/usb/host/whci/debug.c

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