wusb: add debug files for ASL, PZL and DI to the whci-hcd driver

Add asl, pzl and di debugfs files to uwb/uwbN/wusbhc for WHCI host
controller.  These dump the current ASL, PZL and DI buffer.

Signed-off-by: David Vrabel <david.vrabel@csr.com>

8 files changed, 201 insertions, 121 deletions

diff --git a/drivers/usb/host/whci/Kbuild b/drivers/usb/host/whci/Kbuild
index 26a3871ea0f9..11e5040b8337 100644
--- a/drivers/usb/host/whci/Kbuild
+++ b/drivers/usb/host/whci/Kbuild
@@ -2,6 +2,7 @@ obj-$(CONFIG_USB_WHCI_HCD) += whci-hcd.o
 
 whci-hcd-y := \
         asl.o   \
+        debug.o \
         hcd.o   \
         hw.o    \
         init.o  \
diff --git a/drivers/usb/host/whci/asl.c b/drivers/usb/host/whci/asl.c
index ba99a7a3f81a..577c0d29849d 100644
--- a/drivers/usb/host/whci/asl.c
+++ b/drivers/usb/host/whci/asl.c
@@ -19,32 +19,11 @@
 #include <linux/dma-mapping.h>
 #include <linux/uwb/umc.h>
 #include <linux/usb.h>
-#define D_LOCAL 0
-#include <linux/uwb/debug.h>
 
 #include "../../wusbcore/wusbhc.h"
 
 #include "whcd.h"
 
-#if D_LOCAL >= 4
-static void dump_asl(struct whc *whc, const char *tag)
-{
-        struct device *dev = &whc->umc->dev;
-        struct whc_qset *qset;
-
-        d_printf(4, dev, "ASL %s\n", tag);
-
-        list_for_each_entry(qset, &whc->async_list, list_node) {
-                dump_qset(qset, dev);
-        }
-}
-#else
-static inline void dump_asl(struct whc *whc, const char *tag)
-{
-}
-#endif
-
-
 static void qset_get_next_prev(struct whc *whc, struct whc_qset *qset,
                                struct whc_qset **next, struct whc_qset **prev)
 {
@@ -217,8 +196,6 @@ void scan_async_work(struct work_struct *work)
 
         spin_lock_irq(&whc->lock);
 
-        dump_asl(whc, "before processing");
-
         /*
          * Transerve the software list backwards so new qsets can be
          * safely inserted into the ASL without making it non-circular.
@@ -232,8 +209,6 @@ void scan_async_work(struct work_struct *work)
                 update |= process_qset(whc, qset);
         }
 
-        dump_asl(whc, "after processing");
-
         spin_unlock_irq(&whc->lock);
 
         if (update) {
diff --git a/drivers/usb/host/whci/debug.c b/drivers/usb/host/whci/debug.c
new file mode 100644
index 000000000000..cf2d45946c57
--- /dev/null
+++ b/drivers/usb/host/whci/debug.c
@@ -0,0 +1,189 @@
+/*
+ * Wireless Host Controller (WHC) debug.
+ *
+ * Copyright (C) 2008 Cambridge Silicon Radio Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License version
+ * 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <linux/kernel.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+
+#include "../../wusbcore/wusbhc.h"
+
+#include "whcd.h"
+
+struct whc_dbg {
+        struct dentry *di_f;
+        struct dentry *asl_f;
+        struct dentry *pzl_f;
+};
+
+void qset_print(struct seq_file *s, struct whc_qset *qset)
+{
+        struct whc_std *std;
+        struct urb *urb = NULL;
+        int i;
+
+        seq_printf(s, "qset %08x\n", (u32)qset->qset_dma);
+        seq_printf(s, "  -> %08x\n", (u32)qset->qh.link);
+        seq_printf(s, "  info: %08x %08x %08x\n",
+                qset->qh.info1, qset->qh.info2,  qset->qh.info3);
+        seq_printf(s, "  sts: %04x errs: %d\n", qset->qh.status, qset->qh.err_count);
+        seq_printf(s, "  TD: sts: %08x opts: %08x\n",
+                qset->qh.overlay.qtd.status, qset->qh.overlay.qtd.options);
+
+        for (i = 0; i < WHCI_QSET_TD_MAX; i++) {
+                seq_printf(s, "  %c%c TD[%d]: sts: %08x opts: %08x ptr: %08x\n",
+                        i == qset->td_start ? 'S' : ' ',
+                        i == qset->td_end ? 'E' : ' ',
+                        i, qset->qtd[i].status, qset->qtd[i].options,
+                        (u32)qset->qtd[i].page_list_ptr);
+        }
+        seq_printf(s, "  ntds: %d\n", qset->ntds);
+        list_for_each_entry(std, &qset->stds, list_node) {
+                if (urb != std->urb) {
+                        urb = std->urb;
+                        seq_printf(s, "  urb %p transferred: %d bytes\n", urb,
+                                urb->actual_length);
+                }
+                if (std->qtd)
+                        seq_printf(s, "    sTD[%td]: %zu bytes @ %08x\n",
+                                std->qtd - &qset->qtd[0],
+                                std->len, std->num_pointers ?
+                                (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
+                else
+                        seq_printf(s, "    sTD[-]: %zd bytes @ %08x\n",
+                                std->len, std->num_pointers ?
+                                (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
+        }
+}
+
+static int di_print(struct seq_file *s, void *p)
+{
+        struct whc *whc = s->private;
+        char buf[72];
+        int d;
+
+        for (d = 0; d < whc->n_devices; d++) {
+                struct di_buf_entry *di = &whc->di_buf[d];
+
+                bitmap_scnprintf(buf, sizeof(buf),
+                                 (unsigned long *)di->availability_info, UWB_NUM_MAS);
+
+                seq_printf(s, "DI[%d]\n", d);
+                seq_printf(s, "  availability: %s\n", buf);
+                seq_printf(s, "  %c%c key idx: %d dev addr: %d\n",
+                           (di->addr_sec_info & WHC_DI_SECURE) ? 'S' : ' ',
+                           (di->addr_sec_info & WHC_DI_DISABLE) ? 'D' : ' ',
+                           (di->addr_sec_info & WHC_DI_KEY_IDX_MASK) >> 8,
+                           (di->addr_sec_info & WHC_DI_DEV_ADDR_MASK));
+        }
+        return 0;
+}
+
+static int asl_print(struct seq_file *s, void *p)
+{
+        struct whc *whc = s->private;
+        struct whc_qset *qset;
+
+        list_for_each_entry(qset, &whc->async_list, list_node) {
+                qset_print(s, qset);
+        }
+
+        return 0;
+}
+
+static int pzl_print(struct seq_file *s, void *p)
+{
+        struct whc *whc = s->private;
+        struct whc_qset *qset;
+        int period;
+
+        for (period = 0; period < 5; period++) {
+                seq_printf(s, "Period %d\n", period);
+                list_for_each_entry(qset, &whc->periodic_list[period], list_node) {
+                        qset_print(s, qset);
+                }
+        }
+        return 0;
+}
+
+static int di_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, di_print, inode->i_private);
+}
+
+static int asl_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, asl_print, inode->i_private);
+}
+
+static int pzl_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, pzl_print, inode->i_private);
+}
+
+static struct file_operations di_fops = {
+        .open    = di_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release,
+        .owner   = THIS_MODULE,
+};
+
+static struct file_operations asl_fops = {
+        .open    = asl_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release,
+        .owner   = THIS_MODULE,
+};
+
+static struct file_operations pzl_fops = {
+        .open    = pzl_open,
+        .read    = seq_read,
+        .llseek  = seq_lseek,
+        .release = single_release,
+        .owner   = THIS_MODULE,
+};
+
+void whc_dbg_init(struct whc *whc)
+{
+        if (whc->wusbhc.pal.debugfs_dir == NULL)
+                return;
+
+        whc->dbg = kzalloc(sizeof(struct whc_dbg), GFP_KERNEL);
+        if (whc->dbg == NULL)
+                return;
+
+        whc->dbg->di_f = debugfs_create_file("di", 0444,
+                                              whc->wusbhc.pal.debugfs_dir, whc,
+                                              &di_fops);
+        whc->dbg->asl_f = debugfs_create_file("asl", 0444,
+                                              whc->wusbhc.pal.debugfs_dir, whc,
+                                              &asl_fops);
+        whc->dbg->pzl_f = debugfs_create_file("pzl", 0444,
+                                              whc->wusbhc.pal.debugfs_dir, whc,
+                                              &pzl_fops);
+}
+
+void whc_dbg_clean_up(struct whc *whc)
+{
+        if (whc->dbg) {
+                debugfs_remove(whc->dbg->pzl_f);
+                debugfs_remove(whc->dbg->asl_f);
+                debugfs_remove(whc->dbg->di_f);
+                kfree(whc->dbg);
+        }
+}
diff --git a/drivers/usb/host/whci/hcd.c b/drivers/usb/host/whci/hcd.c
index f599f89d3be1..1569afd6245b 100644
--- a/drivers/usb/host/whci/hcd.c
+++ b/drivers/usb/host/whci/hcd.c
@@ -273,6 +273,8 @@ static int whc_probe(struct umc_dev *umc)
                 goto error_wusbhc_b_create;
         }
 
+        whc_dbg_init(whc);
+
         return 0;
 
 error_wusbhc_b_create:
@@ -296,6 +298,7 @@ static void whc_remove(struct umc_dev *umc)
         struct whc *whc = wusbhc_to_whc(wusbhc);
 
         if (usb_hcd) {
+                whc_dbg_clean_up(whc);
                 wusbhc_b_destroy(wusbhc);
                 usb_remove_hcd(usb_hcd);
                 wusbhc_destroy(wusbhc);
diff --git a/drivers/usb/host/whci/pzl.c b/drivers/usb/host/whci/pzl.c
index 34d3a0aeab2b..2ae5abf69a6a 100644
--- a/drivers/usb/host/whci/pzl.c
+++ b/drivers/usb/host/whci/pzl.c
@@ -19,35 +19,11 @@
 #include <linux/dma-mapping.h>
 #include <linux/uwb/umc.h>
 #include <linux/usb.h>
-#define D_LOCAL 0
-#include <linux/uwb/debug.h>
 
 #include "../../wusbcore/wusbhc.h"
 
 #include "whcd.h"
 
-#if D_LOCAL >= 4
-static void dump_pzl(struct whc *whc, const char *tag)
-{
-        struct device *dev = &whc->umc->dev;
-        struct whc_qset *qset;
-        int period = 0;
-
-        d_printf(4, dev, "PZL %s\n", tag);
-
-        for (period = 0; period < 5; period++) {
-                d_printf(4, dev, "Period %d\n", period);
-                list_for_each_entry(qset, &whc->periodic_list[period], list_node) {
-                        dump_qset(qset, dev);
-                }
-        }
-}
-#else
-static inline void dump_pzl(struct whc *whc, const char *tag)
-{
-}
-#endif
-
 static void update_pzl_pointers(struct whc *whc, int period, u64 addr)
 {
         switch (period) {
@@ -250,8 +226,6 @@ void scan_periodic_work(struct work_struct *work)
 
         spin_lock_irq(&whc->lock);
 
-        dump_pzl(whc, "before processing");
-
         for (period = 4; period >= 0; period--) {
                 list_for_each_entry_safe(qset, t, &whc->periodic_list[period], list_node) {
                         if (!qset->in_hw_list)
@@ -263,8 +237,6 @@ void scan_periodic_work(struct work_struct *work)
         if (update & (WHC_UPDATE_ADDED | WHC_UPDATE_REMOVED))
                 update_pzl_hw_view(whc);
 
-        dump_pzl(whc, "after processing");
-
         spin_unlock_irq(&whc->lock);
 
         if (update) {
diff --git a/drivers/usb/host/whci/qset.c b/drivers/usb/host/whci/qset.c
index 0420037d2e18..7be74314ee12 100644
--- a/drivers/usb/host/whci/qset.c
+++ b/drivers/usb/host/whci/qset.c
@@ -24,46 +24,6 @@
 
 #include "whcd.h"
 
-void dump_qset(struct whc_qset *qset, struct device *dev)
-{
-        struct whc_std *std;
-        struct urb *urb = NULL;
-        int i;
-
-        dev_dbg(dev, "qset %08x\n", (u32)qset->qset_dma);
-        dev_dbg(dev, "  -> %08x\n", (u32)qset->qh.link);
-        dev_dbg(dev, "  info: %08x %08x %08x\n",
-                qset->qh.info1, qset->qh.info2,  qset->qh.info3);
-        dev_dbg(dev, "  sts: %04x errs: %d\n", qset->qh.status, qset->qh.err_count);
-        dev_dbg(dev, "  TD: sts: %08x opts: %08x\n",
-                qset->qh.overlay.qtd.status, qset->qh.overlay.qtd.options);
-
-        for (i = 0; i < WHCI_QSET_TD_MAX; i++) {
-                dev_dbg(dev, "  %c%c TD[%d]: sts: %08x opts: %08x ptr: %08x\n",
-                        i == qset->td_start ? 'S' : ' ',
-                        i == qset->td_end ? 'E' : ' ',
-                        i, qset->qtd[i].status, qset->qtd[i].options,
-                        (u32)qset->qtd[i].page_list_ptr);
-        }
-        dev_dbg(dev, "  ntds: %d\n", qset->ntds);
-        list_for_each_entry(std, &qset->stds, list_node) {
-                if (urb != std->urb) {
-                        urb = std->urb;
-                        dev_dbg(dev, "  urb %p transferred: %d bytes\n", urb,
-                                urb->actual_length);
-                }
-                if (std->qtd)
-                        dev_dbg(dev, "    sTD[%td]: %zu bytes @ %08x\n",
-                                std->qtd - &qset->qtd[0],
-                                std->len, std->num_pointers ?
-                                (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
-                else
-                        dev_dbg(dev, "    sTD[-]: %zd bytes @ %08x\n",
-                                std->len, std->num_pointers ?
-                                (u32)(std->pl_virt[0].buf_ptr) : (u32)std->dma_addr);
-        }
-}
-
 struct whc_qset *qset_alloc(struct whc *whc, gfp_t mem_flags)
 {
         struct whc_qset *qset;
diff --git a/drivers/usb/host/whci/whcd.h b/drivers/usb/host/whci/whcd.h
index 1bbb8cb6bf80..0f3540f04f53 100644
--- a/drivers/usb/host/whci/whcd.h
+++ b/drivers/usb/host/whci/whcd.h
@@ -21,6 +21,7 @@
 #define __WHCD_H
 
 #include <linux/uwb/whci.h>
+#include <linux/uwb/umc.h>
 #include <linux/workqueue.h>
 
 #include "whci-hc.h"
@@ -28,6 +29,7 @@
 /* Generic command timeout. */
 #define WHC_GENCMD_TIMEOUT_MS 100
 
+struct whc_dbg;
 
 struct whc {
         struct wusbhc wusbhc;
@@ -69,6 +71,8 @@ struct whc {
         struct list_head periodic_removed_list;
         wait_queue_head_t periodic_list_wq;
         struct work_struct periodic_work;
+
+        struct whc_dbg *dbg;
 };
 
 #define wusbhc_to_whc(w) (container_of((w), struct whc, wusbhc))
@@ -190,8 +194,11 @@ void process_inactive_qtd(struct whc *whc, struct whc_qset *qset,
                                  struct whc_qtd *qtd);
 enum whc_update qset_add_qtds(struct whc *whc, struct whc_qset *qset);
 void qset_remove_complete(struct whc *whc, struct whc_qset *qset);
-void dump_qset(struct whc_qset *qset, struct device *dev);
 void pzl_update(struct whc *whc, uint32_t wusbcmd);
 void asl_update(struct whc *whc, uint32_t wusbcmd);
 
+/* debug.c */
+void whc_dbg_init(struct whc *whc);
+void whc_dbg_clean_up(struct whc *whc);
+
 #endif /* #ifndef __WHCD_H */
diff --git a/drivers/usb/host/whci/wusb.c b/drivers/usb/host/whci/wusb.c
index 540021a0971e..f24efdebad17 100644
--- a/drivers/usb/host/whci/wusb.c
+++ b/drivers/usb/host/whci/wusb.c
@@ -18,43 +18,16 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/uwb/umc.h>
-#define D_LOCAL 1
-#include <linux/uwb/debug.h>
 
 #include "../../wusbcore/wusbhc.h"
 
 #include "whcd.h"
 
-#if D_LOCAL >= 1
-static void dump_di(struct whc *whc, int idx)
-{
-        struct di_buf_entry *di = &whc->di_buf[idx];
-        struct device *dev = &whc->umc->dev;
-        char buf[128];
-
-        bitmap_scnprintf(buf, sizeof(buf), (unsigned long *)di->availability_info, UWB_NUM_MAS);
-
-        d_printf(1, dev, "DI[%d]\n", idx);
-        d_printf(1, dev, "  availability: %s\n", buf);
-        d_printf(1, dev, "  %c%c key idx: %d dev addr: %d\n",
-                 (di->addr_sec_info & WHC_DI_SECURE) ? 'S' : ' ',
-                 (di->addr_sec_info & WHC_DI_DISABLE) ? 'D' : ' ',
-                 (di->addr_sec_info & WHC_DI_KEY_IDX_MASK) >> 8,
-                 (di->addr_sec_info & WHC_DI_DEV_ADDR_MASK));
-}
-#else
-static inline void dump_di(struct whc *whc, int idx)
-{
-}
-#endif
-
 static int whc_update_di(struct whc *whc, int idx)
 {
         int offset = idx / 32;
         u32 bit = 1 << (idx % 32);
 
-        dump_di(whc, idx);
-
         le_writel(bit, whc->base + WUSBDIBUPDATED + offset);
 
         return whci_wait_for(&whc->umc->dev,