Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dcc7461e authored by David Vrabel's avatar David Vrabel
Browse files

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: default avatarDavid Vrabel <david.vrabel@csr.com>
parent e4b49580

drivers/usb/host/whci/Kbuild

+1 −0
Original line number Diff line number Diff line
@@ -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	\

drivers/usb/host/whci/asl.c

+0 −25
Original line number Diff line number Diff line
@@ -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) {

drivers/usb/host/whci/debug.c

0 → 100644
+189 −0
Original line number Diff line number Diff line 
/*

 * 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);

	}

}

drivers/usb/host/whci/hcd.c

+3 −0
Original line number Diff line number Diff line
@@ -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);

drivers/usb/host/whci/pzl.c

+0 −28
Original line number Diff line number Diff line
@@ -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) {