Commit 9269e3c3 authored by Kuninori Morimoto's avatar Kuninori Morimoto Committed by Mark Brown
Browse files

ASoC: rsnd: add CTU (Channel Transfer Unit) prototype support 



This patch adds CTU (Channel Transfer Unit) support for rsnd driver.
But, it does nothing to data at this point, but is required for MIX
support.

CTU design is a little different from other IPs (CTU0 is including
CTU00 - CTU03, and CTU1 is including CTU10 - CTU13, these have different
register mapping) We need to care about it on this driver.

Signed-off-by: default avatarKuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Tested-by: default avatarKeita Kobayashi <keita.kobayashi.ym@renesas.com>
Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 7dfb4919

Documentation/devicetree/bindings/sound/renesas,rsnd.txt

+14 −0
Original line number Diff line number Diff line
@@ -18,6 +18,9 @@ Required properties: 
- rcar_sound,src		: Should contain SRC feature.

				  The number of SRC subnode should be same as HW.

				  see below for detail.

- rcar_sound,ctu		: Should contain CTU feature.

				  The number of CTU subnode should be same as HW.

				  see below for detail.

- rcar_sound,dvc		: Should contain DVC feature.

				  The number of DVC subnode should be same as HW.

				  see below for detail.
@@ -90,6 +93,17 @@ rcar_sound: sound@ec500000 { 
		};

	};



	rcar_sound,ctu {

		ctu00: ctu@0 { };

		ctu01: ctu@1 { };

		ctu02: ctu@2 { };

		ctu03: ctu@3 { };

		ctu10: ctu@4 { };

		ctu11: ctu@5 { };

		ctu12: ctu@6 { };

		ctu13: ctu@7 { };

	};



	rcar_sound,src {

		src0: src@0 {

			interrupts = <0 352 IRQ_TYPE_LEVEL_HIGH>;

include/sound/rcar_snd.h

+7 −0
Original line number Diff line number Diff line
@@ -61,6 +61,10 @@ struct rsnd_src_platform_info { 
/*

 * flags

 */

struct rsnd_ctu_platform_info {

	u32 flags;

};



struct rsnd_dvc_platform_info {

	u32 flags;

};
@@ -68,6 +72,7 @@ struct rsnd_dvc_platform_info { 
struct rsnd_dai_path_info {

	struct rsnd_ssi_platform_info *ssi;

	struct rsnd_src_platform_info *src;

	struct rsnd_ctu_platform_info *ctu;

	struct rsnd_dvc_platform_info *dvc;

};
@@ -93,6 +98,8 @@ struct rcar_snd_info { 
	int ssi_info_nr;

	struct rsnd_src_platform_info *src_info;

	int src_info_nr;

	struct rsnd_ctu_platform_info *ctu_info;

	int ctu_info_nr;

	struct rsnd_dvc_platform_info *dvc_info;

	int dvc_info_nr;

	struct rsnd_dai_platform_info *dai_info;

sound/soc/sh/rcar/Makefile

+1 −1
Original line number Diff line number Diff line 
snd-soc-rcar-objs	:= core.o gen.o dma.o adg.o ssi.o src.o dvc.o

snd-soc-rcar-objs	:= core.o gen.o dma.o adg.o ssi.o src.o ctu.o dvc.o

obj-$(CONFIG_SND_SOC_RCAR)	+= snd-soc-rcar.o



snd-soc-rsrc-card-objs	:= rsrc-card.o

sound/soc/sh/rcar/core.c

+11 −1
Original line number Diff line number Diff line
@@ -651,6 +651,11 @@ static int rsnd_path_init(struct rsnd_priv *priv, 
	if (ret < 0)

		return ret;



	/* CTU */

	ret = rsnd_path_add(priv, io, ctu);

	if (ret < 0)

		return ret;



	/* DVC */

	ret = rsnd_path_add(priv, io, dvc);

	if (ret < 0)
@@ -666,13 +671,14 @@ static void rsnd_of_parse_dai(struct platform_device *pdev, 
	struct device_node *dai_node,	*dai_np;

	struct device_node *ssi_node,	*ssi_np;

	struct device_node *src_node,	*src_np;

	struct device_node *ctu_node,	*ctu_np;

	struct device_node *dvc_node,	*dvc_np;

	struct device_node *playback, *capture;

	struct rsnd_dai_platform_info *dai_info;

	struct rcar_snd_info *info = rsnd_priv_to_info(priv);

	struct device *dev = &pdev->dev;

	int nr, i;

	int dai_i, ssi_i, src_i, dvc_i;

	int dai_i, ssi_i, src_i, ctu_i, dvc_i;



	if (!of_data)

		return;
@@ -698,6 +704,7 @@ static void rsnd_of_parse_dai(struct platform_device *pdev, 


	ssi_node = of_get_child_by_name(dev->of_node, "rcar_sound,ssi");

	src_node = of_get_child_by_name(dev->of_node, "rcar_sound,src");

	ctu_node = of_get_child_by_name(dev->of_node, "rcar_sound,ctu");

	dvc_node = of_get_child_by_name(dev->of_node, "rcar_sound,dvc");



#define mod_parse(name)							\
@@ -734,6 +741,7 @@ if (name##_node) { \ 


			mod_parse(ssi);

			mod_parse(src);

			mod_parse(ctu);

			mod_parse(dvc);



			of_node_put(playback);
@@ -1146,6 +1154,7 @@ static int rsnd_probe(struct platform_device *pdev) 
		rsnd_dma_probe,

		rsnd_ssi_probe,

		rsnd_src_probe,

		rsnd_ctu_probe,

		rsnd_dvc_probe,

		rsnd_adg_probe,

		rsnd_dai_probe,
@@ -1241,6 +1250,7 @@ static int rsnd_remove(struct platform_device *pdev) 
			      struct rsnd_priv *priv) = {

		rsnd_ssi_remove,

		rsnd_src_remove,

		rsnd_ctu_remove,

		rsnd_dvc_remove,

	};

	int ret = 0, i;

sound/soc/sh/rcar/ctu.c

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

 * ctu.c

 *

 * Copyright (c) 2015 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>

 *

 * 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.

 */

#include "rsnd.h"



#define CTU_NAME_SIZE	16

#define CTU_NAME "ctu"



struct rsnd_ctu {

	struct rsnd_ctu_platform_info *info; /* rcar_snd.h */

	struct rsnd_mod mod;

};



#define rsnd_ctu_nr(priv) ((priv)->ctu_nr)

#define for_each_rsnd_ctu(pos, priv, i)					\

	for ((i) = 0;							\

	     ((i) < rsnd_ctu_nr(priv)) &&				\

		     ((pos) = (struct rsnd_ctu *)(priv)->ctu + i);	\

	     i++)



#define rsnd_ctu_initialize_lock(mod)	__rsnd_ctu_initialize_lock(mod, 1)

#define rsnd_ctu_initialize_unlock(mod)	__rsnd_ctu_initialize_lock(mod, 0)

static void __rsnd_ctu_initialize_lock(struct rsnd_mod *mod, u32 enable)

{

	rsnd_mod_write(mod, CTU_CTUIR, enable);

}



static int rsnd_ctu_init(struct rsnd_mod *mod,

			 struct rsnd_dai_stream *io,

			 struct rsnd_priv *priv)

{

	rsnd_mod_hw_start(mod);



	rsnd_ctu_initialize_lock(mod);



	rsnd_mod_write(mod, CTU_ADINR, rsnd_get_adinr_chan(mod, io));



	rsnd_ctu_initialize_unlock(mod);



	return 0;

}



static int rsnd_ctu_quit(struct rsnd_mod *mod,

			 struct rsnd_dai_stream *io,

			 struct rsnd_priv *priv)

{

	rsnd_mod_hw_stop(mod);



	return 0;

}



static struct rsnd_mod_ops rsnd_ctu_ops = {

	.name		= CTU_NAME,

	.init		= rsnd_ctu_init,

	.quit		= rsnd_ctu_quit,

};



struct rsnd_mod *rsnd_ctu_mod_get(struct rsnd_priv *priv, int id)

{

	if (WARN_ON(id < 0 || id >= rsnd_ctu_nr(priv)))

		id = 0;



	return &((struct rsnd_ctu *)(priv->ctu) + id)->mod;

}



void rsnd_of_parse_ctu(struct platform_device *pdev,

		       const struct rsnd_of_data *of_data,

		       struct rsnd_priv *priv)

{

	struct device_node *node;

	struct rsnd_ctu_platform_info *ctu_info;

	struct rcar_snd_info *info = rsnd_priv_to_info(priv);

	struct device *dev = &pdev->dev;

	int nr;



	if (!of_data)

		return;



	node = of_get_child_by_name(dev->of_node, "rcar_sound,ctu");

	if (!node)

		return;



	nr = of_get_child_count(node);

	if (!nr)

		goto rsnd_of_parse_ctu_end;



	ctu_info = devm_kzalloc(dev,

				sizeof(struct rsnd_ctu_platform_info) * nr,

				GFP_KERNEL);

	if (!ctu_info) {

		dev_err(dev, "ctu info allocation error\n");

		goto rsnd_of_parse_ctu_end;

	}



	info->ctu_info		= ctu_info;

	info->ctu_info_nr	= nr;



rsnd_of_parse_ctu_end:

	of_node_put(node);



}



int rsnd_ctu_probe(struct platform_device *pdev,

		   const struct rsnd_of_data *of_data,

		   struct rsnd_priv *priv)

{

	struct rcar_snd_info *info = rsnd_priv_to_info(priv);

	struct device *dev = rsnd_priv_to_dev(priv);

	struct rsnd_ctu *ctu;

	struct clk *clk;

	char name[CTU_NAME_SIZE];

	int i, nr, ret;



	/* This driver doesn't support Gen1 at this point */

	if (rsnd_is_gen1(priv)) {

		dev_warn(dev, "CTU is not supported on Gen1\n");

		return -EINVAL;

	}



	rsnd_of_parse_ctu(pdev, of_data, priv);



	nr = info->ctu_info_nr;

	if (!nr)

		return 0;



	ctu = devm_kzalloc(dev, sizeof(*ctu) * nr, GFP_KERNEL);

	if (!ctu)

		return -ENOMEM;



	priv->ctu_nr	= nr;

	priv->ctu	= ctu;



	for_each_rsnd_ctu(ctu, priv, i) {

		/*

		 * CTU00, CTU01, CTU02, CTU03 => CTU0

		 * CTU10, CTU11, CTU12, CTU13 => CTU1

		 */

		snprintf(name, CTU_NAME_SIZE, "%s.%d",

			 CTU_NAME, i / 4);



		clk = devm_clk_get(dev, name);

		if (IS_ERR(clk))

			return PTR_ERR(clk);



		ctu->info = &info->ctu_info[i];



		ret = rsnd_mod_init(priv, &ctu->mod, &rsnd_ctu_ops,

				    clk, RSND_MOD_CTU, i);

		if (ret)

			return ret;

	}



	return 0;

}



void rsnd_ctu_remove(struct platform_device *pdev,

		     struct rsnd_priv *priv)

{

	struct rsnd_ctu *ctu;

	int i;



	for_each_rsnd_ctu(ctu, priv, i) {

		rsnd_mod_quit(&ctu->mod);

	}

}