ASoC: rsnd: add CTU (Channel Transfer Unit) prototype support (9269e3c3) · Commits · 戴 / test

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

Admin message