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

Commit f138e621 authored by Markus Pargmann's avatar Markus Pargmann Committed by Mark Brown
Browse files

ASoC: fsl-ssi: Move debugging to seperate file 



Move all code that is only used for debugging to a seperate file. This
makes it easier to see what functions are used for debugging only.

Signed-off-by: default avatarMarkus Pargmann <mpa@pengutronix.de>
Tested-By: default avatarMichael Grzeschik <mgr@pengutronix.de>
Signed-off-by: default avatarMark Brown <broonie@linaro.org>
parent 65c961cc

sound/soc/fsl/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -12,7 +12,8 @@ obj-$(CONFIG_SND_SOC_P1022_RDK) += snd-soc-p1022-rdk.o 


# Freescale SSI/DMA/SAI/SPDIF Support

snd-soc-fsl-sai-objs := fsl_sai.o

snd-soc-fsl-ssi-objs := fsl_ssi.o

snd-soc-fsl-ssi-y := fsl_ssi.o

snd-soc-fsl-ssi-$(CONFIG_DEBUG_FS) += fsl_ssi_dbg.o

snd-soc-fsl-spdif-objs := fsl_spdif.o

snd-soc-fsl-esai-objs := fsl_esai.o

snd-soc-fsl-utils-objs := fsl_utils.o

sound/soc/fsl/fsl_ssi.c

+7 −234
Original line number Diff line number Diff line
@@ -35,7 +35,6 @@ 
#include <linux/module.h>

#include <linux/interrupt.h>

#include <linux/clk.h>

#include <linux/debugfs.h>

#include <linux/device.h>

#include <linux/delay.h>

#include <linux/slab.h>
@@ -113,8 +112,6 @@ static inline void write_ssi_mask(u32 __iomem *addr, u32 clear, u32 set) 
#define FSLSSI_SIER_DBG_TX_FLAGS (CCSR_SSI_SIER_TFE0_EN | \

		CCSR_SSI_SIER_TLS_EN | CCSR_SSI_SIER_TFS_EN | \

		CCSR_SSI_SIER_TUE0_EN | CCSR_SSI_SIER_TFRC_EN)

#define FSLSSI_SISR_MASK (FSLSSI_SIER_DBG_RX_FLAGS | FSLSSI_SIER_DBG_TX_FLAGS)





enum fsl_ssi_type {

	FSL_SSI_MCP8610,
@@ -177,31 +174,7 @@ struct fsl_ssi_private { 
	/* Register values for rx/tx configuration */

	struct fsl_ssi_rxtx_reg_val rxtx_reg_val;



	struct {

		unsigned int rfrc;

		unsigned int tfrc;

		unsigned int cmdau;

		unsigned int cmddu;

		unsigned int rxt;

		unsigned int rdr1;

		unsigned int rdr0;

		unsigned int tde1;

		unsigned int tde0;

		unsigned int roe1;

		unsigned int roe0;

		unsigned int tue1;

		unsigned int tue0;

		unsigned int tfs;

		unsigned int rfs;

		unsigned int tls;

		unsigned int rls;

		unsigned int rff1;

		unsigned int rff0;

		unsigned int tfe1;

		unsigned int tfe0;

	} stats;

	struct dentry *dbg_dir;

	struct dentry *dbg_stats;

	struct fsl_ssi_dbg dbg_stats;



	char name[1];

};
@@ -231,7 +204,6 @@ static irqreturn_t fsl_ssi_isr(int irq, void *dev_id) 
{

	struct fsl_ssi_private *ssi_private = dev_id;

	struct ccsr_ssi __iomem *ssi = ssi_private->ssi;

	irqreturn_t ret = IRQ_NONE;

	__be32 sisr;

	__be32 sisr2;

	__be32 sisr_write_mask = 0;
@@ -258,217 +230,18 @@ static irqreturn_t fsl_ssi_isr(int irq, void *dev_id) 
	   were interrupted for.  We mask it with the Interrupt Enable register

	   so that we only check for events that we're interested in.

	 */

	sisr = read_ssi(&ssi->sisr) & FSLSSI_SISR_MASK;



	if (sisr & CCSR_SSI_SISR_RFRC) {

		ssi_private->stats.rfrc++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_TFRC) {

		ssi_private->stats.tfrc++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_CMDAU) {

		ssi_private->stats.cmdau++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_CMDDU) {

		ssi_private->stats.cmddu++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_RXT) {

		ssi_private->stats.rxt++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_RDR1) {

		ssi_private->stats.rdr1++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_RDR0) {

		ssi_private->stats.rdr0++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_TDE1) {

		ssi_private->stats.tde1++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_TDE0) {

		ssi_private->stats.tde0++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_ROE1) {

		ssi_private->stats.roe1++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_ROE0) {

		ssi_private->stats.roe0++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_TUE1) {

		ssi_private->stats.tue1++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_TUE0) {

		ssi_private->stats.tue0++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_TFS) {

		ssi_private->stats.tfs++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_RFS) {

		ssi_private->stats.rfs++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_TLS) {

		ssi_private->stats.tls++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_RLS) {

		ssi_private->stats.rls++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_RFF1) {

		ssi_private->stats.rff1++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_RFF0) {

		ssi_private->stats.rff0++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_TFE1) {

		ssi_private->stats.tfe1++;

		ret = IRQ_HANDLED;

	}



	if (sisr & CCSR_SSI_SISR_TFE0) {

		ssi_private->stats.tfe0++;

		ret = IRQ_HANDLED;

	}

	sisr = read_ssi(&ssi->sisr);



	sisr2 = sisr & sisr_write_mask;

	/* Clear the bits that we set */

	if (sisr2)

		write_ssi(sisr2, &ssi->sisr);



	return ret;

}



#if IS_ENABLED(CONFIG_DEBUG_FS)

/* Show the statistics of a flag only if its interrupt is enabled.  The

 * compiler will optimze this code to a no-op if the interrupt is not

 * enabled.

 */

#define SIER_SHOW(flag, name) \

	do { \

		if (FSLSSI_SISR_MASK & CCSR_SSI_SIER_##flag) \

			seq_printf(s, #name "=%u\n", ssi_private->stats.name); \

	} while (0)





/**

 * fsl_sysfs_ssi_show: display SSI statistics

 *

 * Display the statistics for the current SSI device.  To avoid confusion,

 * we only show those counts that are enabled.

 */

static int fsl_ssi_stats_show(struct seq_file *s, void *unused)

{

	struct fsl_ssi_private *ssi_private = s->private;



	SIER_SHOW(RFRC_EN, rfrc);

	SIER_SHOW(TFRC_EN, tfrc);

	SIER_SHOW(CMDAU_EN, cmdau);

	SIER_SHOW(CMDDU_EN, cmddu);

	SIER_SHOW(RXT_EN, rxt);

	SIER_SHOW(RDR1_EN, rdr1);

	SIER_SHOW(RDR0_EN, rdr0);

	SIER_SHOW(TDE1_EN, tde1);

	SIER_SHOW(TDE0_EN, tde0);

	SIER_SHOW(ROE1_EN, roe1);

	SIER_SHOW(ROE0_EN, roe0);

	SIER_SHOW(TUE1_EN, tue1);

	SIER_SHOW(TUE0_EN, tue0);

	SIER_SHOW(TFS_EN, tfs);

	SIER_SHOW(RFS_EN, rfs);

	SIER_SHOW(TLS_EN, tls);

	SIER_SHOW(RLS_EN, rls);

	SIER_SHOW(RFF1_EN, rff1);

	SIER_SHOW(RFF0_EN, rff0);

	SIER_SHOW(TFE1_EN, tfe1);

	SIER_SHOW(TFE0_EN, tfe0);



	return 0;

}



static int fsl_ssi_stats_open(struct inode *inode, struct file *file)

{

	return single_open(file, fsl_ssi_stats_show, inode->i_private);

}



static const struct file_operations fsl_ssi_stats_ops = {

	.open = fsl_ssi_stats_open,

	.read = seq_read,

	.llseek = seq_lseek,

	.release = single_release,

};



static int fsl_ssi_debugfs_create(struct fsl_ssi_private *ssi_private,

		struct device *dev)

{

	ssi_private->dbg_dir = debugfs_create_dir(dev_name(dev), NULL);

	if (!ssi_private->dbg_dir)

		return -ENOMEM;



	ssi_private->dbg_stats = debugfs_create_file("stats", S_IRUGO,

			ssi_private->dbg_dir, ssi_private, &fsl_ssi_stats_ops);

	if (!ssi_private->dbg_stats) {

		debugfs_remove(ssi_private->dbg_dir);

		return -ENOMEM;

	}



	return 0;

}



static void fsl_ssi_debugfs_remove(struct fsl_ssi_private *ssi_private)

{

	debugfs_remove(ssi_private->dbg_stats);

	debugfs_remove(ssi_private->dbg_dir);

}



#else



static int fsl_ssi_debugfs_create(struct fsl_ssi_private *ssi_private,

		struct device *dev)

{

	return 0;

}

	fsl_ssi_dbg_isr(&ssi_private->dbg_stats, sisr);



static void fsl_ssi_debugfs_remove(struct fsl_ssi_private *ssi_private)

{

	return IRQ_HANDLED;

}



#endif /* IS_ENABLED(CONFIG_DEBUG_FS) */



/*

 * Enable/Disable all rx/tx config flags at once.

 */
@@ -1452,7 +1225,7 @@ static int fsl_ssi_probe(struct platform_device *pdev) 
		goto error_dev;

	}



	ret = fsl_ssi_debugfs_create(ssi_private, &pdev->dev);

	ret = fsl_ssi_debugfs_create(&ssi_private->dbg_stats, &pdev->dev);

	if (ret)

		goto error_dbgfs;
@@ -1522,7 +1295,7 @@ error_dai: 
		imx_pcm_fiq_exit(pdev);



error_pcm:

	fsl_ssi_debugfs_remove(ssi_private);

	fsl_ssi_debugfs_remove(&ssi_private->dbg_stats);



error_dbgfs:

	snd_soc_unregister_component(&pdev->dev);
@@ -1548,7 +1321,7 @@ static int fsl_ssi_remove(struct platform_device *pdev) 
{

	struct fsl_ssi_private *ssi_private = dev_get_drvdata(&pdev->dev);



	fsl_ssi_debugfs_remove(ssi_private);

	fsl_ssi_debugfs_remove(&ssi_private->dbg_stats);



	if (!ssi_private->new_binding)

		platform_device_unregister(ssi_private->pdev);

sound/soc/fsl/fsl_ssi.h

+60 −1
Original line number Diff line number Diff line
@@ -206,5 +206,64 @@ struct ccsr_ssi { 
#define CCSR_SSI_SACNT_FV		0x00000002

#define CCSR_SSI_SACNT_AC97EN		0x00000001



#endif



struct device;



#if IS_ENABLED(CONFIG_DEBUG_FS)



struct fsl_ssi_dbg {

	struct dentry *dbg_dir;

	struct dentry *dbg_stats;



	struct {

		unsigned int rfrc;

		unsigned int tfrc;

		unsigned int cmdau;

		unsigned int cmddu;

		unsigned int rxt;

		unsigned int rdr1;

		unsigned int rdr0;

		unsigned int tde1;

		unsigned int tde0;

		unsigned int roe1;

		unsigned int roe0;

		unsigned int tue1;

		unsigned int tue0;

		unsigned int tfs;

		unsigned int rfs;

		unsigned int tls;

		unsigned int rls;

		unsigned int rff1;

		unsigned int rff0;

		unsigned int tfe1;

		unsigned int tfe0;

	} stats;

};



void fsl_ssi_dbg_isr(struct fsl_ssi_dbg *ssi_dbg, u32 sisr);



int fsl_ssi_debugfs_create(struct fsl_ssi_dbg *ssi_dbg, struct device *dev);



void fsl_ssi_debugfs_remove(struct fsl_ssi_dbg *ssi_dbg);



#else



struct fsl_ssi_dbg {

};



static inline void fsl_ssi_dbg_isr(struct fsl_ssi_dbg *stats, u32 sisr)

{

}



static inline int fsl_ssi_debugfs_create(struct fsl_ssi_dbg *ssi_dbg,

		struct device *dev)

{

	return 0;

}



static inline void fsl_ssi_debugfs_remove(struct fsl_ssi_dbg *ssi_dbg)

{

}

#endif  /* ! IS_ENABLED(CONFIG_DEBUG_FS) */



#endif

sound/soc/fsl/fsl_ssi_dbg.c

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

 * Freescale SSI ALSA SoC Digital Audio Interface (DAI) debugging functions

 *

 * Copyright 2014 Markus Pargmann <mpa@pengutronix.de>, Pengutronix

 *

 * Splitted from fsl_ssi.c

 *

 * This file is licensed under the terms of the GNU General Public License

 * version 2.  This program is licensed "as is" without any warranty of any

 * kind, whether express or implied.

 */



#include <linux/debugfs.h>

#include <linux/device.h>

#include <linux/kernel.h>



#include "fsl_ssi.h"



void fsl_ssi_dbg_isr(struct fsl_ssi_dbg *dbg, u32 sisr)

{

	if (sisr & CCSR_SSI_SISR_RFRC)

		dbg->stats.rfrc++;



	if (sisr & CCSR_SSI_SISR_TFRC)

		dbg->stats.tfrc++;



	if (sisr & CCSR_SSI_SISR_CMDAU)

		dbg->stats.cmdau++;



	if (sisr & CCSR_SSI_SISR_CMDDU)

		dbg->stats.cmddu++;



	if (sisr & CCSR_SSI_SISR_RXT)

		dbg->stats.rxt++;



	if (sisr & CCSR_SSI_SISR_RDR1)

		dbg->stats.rdr1++;



	if (sisr & CCSR_SSI_SISR_RDR0)

		dbg->stats.rdr0++;



	if (sisr & CCSR_SSI_SISR_TDE1)

		dbg->stats.tde1++;



	if (sisr & CCSR_SSI_SISR_TDE0)

		dbg->stats.tde0++;



	if (sisr & CCSR_SSI_SISR_ROE1)

		dbg->stats.roe1++;



	if (sisr & CCSR_SSI_SISR_ROE0)

		dbg->stats.roe0++;



	if (sisr & CCSR_SSI_SISR_TUE1)

		dbg->stats.tue1++;



	if (sisr & CCSR_SSI_SISR_TUE0)

		dbg->stats.tue0++;



	if (sisr & CCSR_SSI_SISR_TFS)

		dbg->stats.tfs++;



	if (sisr & CCSR_SSI_SISR_RFS)

		dbg->stats.rfs++;



	if (sisr & CCSR_SSI_SISR_TLS)

		dbg->stats.tls++;



	if (sisr & CCSR_SSI_SISR_RLS)

		dbg->stats.rls++;



	if (sisr & CCSR_SSI_SISR_RFF1)

		dbg->stats.rff1++;



	if (sisr & CCSR_SSI_SISR_RFF0)

		dbg->stats.rff0++;



	if (sisr & CCSR_SSI_SISR_TFE1)

		dbg->stats.tfe1++;



	if (sisr & CCSR_SSI_SISR_TFE0)

		dbg->stats.tfe0++;

}



/* Show the statistics of a flag only if its interrupt is enabled.  The

 * compiler will optimze this code to a no-op if the interrupt is not

 * enabled.

 */

#define SIER_SHOW(flag, name) \

	do { \

		if (CCSR_SSI_SIER_##flag) \

			seq_printf(s, #name "=%u\n", ssi_dbg->stats.name); \

	} while (0)





/**

 * fsl_sysfs_ssi_show: display SSI statistics

 *

 * Display the statistics for the current SSI device.  To avoid confusion,

 * we only show those counts that are enabled.

 */

static int fsl_ssi_stats_show(struct seq_file *s, void *unused)

{

	struct fsl_ssi_dbg *ssi_dbg = s->private;



	SIER_SHOW(RFRC_EN, rfrc);

	SIER_SHOW(TFRC_EN, tfrc);

	SIER_SHOW(CMDAU_EN, cmdau);

	SIER_SHOW(CMDDU_EN, cmddu);

	SIER_SHOW(RXT_EN, rxt);

	SIER_SHOW(RDR1_EN, rdr1);

	SIER_SHOW(RDR0_EN, rdr0);

	SIER_SHOW(TDE1_EN, tde1);

	SIER_SHOW(TDE0_EN, tde0);

	SIER_SHOW(ROE1_EN, roe1);

	SIER_SHOW(ROE0_EN, roe0);

	SIER_SHOW(TUE1_EN, tue1);

	SIER_SHOW(TUE0_EN, tue0);

	SIER_SHOW(TFS_EN, tfs);

	SIER_SHOW(RFS_EN, rfs);

	SIER_SHOW(TLS_EN, tls);

	SIER_SHOW(RLS_EN, rls);

	SIER_SHOW(RFF1_EN, rff1);

	SIER_SHOW(RFF0_EN, rff0);

	SIER_SHOW(TFE1_EN, tfe1);

	SIER_SHOW(TFE0_EN, tfe0);



	return 0;

}



static int fsl_ssi_stats_open(struct inode *inode, struct file *file)

{

	return single_open(file, fsl_ssi_stats_show, inode->i_private);

}



static const struct file_operations fsl_ssi_stats_ops = {

	.open = fsl_ssi_stats_open,

	.read = seq_read,

	.llseek = seq_lseek,

	.release = single_release,

};



int fsl_ssi_debugfs_create(struct fsl_ssi_dbg *ssi_dbg, struct device *dev)

{

	ssi_dbg->dbg_dir = debugfs_create_dir(dev_name(dev), NULL);

	if (!ssi_dbg->dbg_dir)

		return -ENOMEM;



	ssi_dbg->dbg_stats = debugfs_create_file("stats", S_IRUGO,

			ssi_dbg->dbg_dir, ssi_dbg, &fsl_ssi_stats_ops);

	if (!ssi_dbg->dbg_stats) {

		debugfs_remove(ssi_dbg->dbg_dir);

		return -ENOMEM;

	}



	return 0;

}



void fsl_ssi_debugfs_remove(struct fsl_ssi_dbg *ssi_dbg)

{

	debugfs_remove(ssi_dbg->dbg_stats);

	debugfs_remove(ssi_dbg->dbg_dir);

}