[linux-2.6-block.git] / sound / soc / sh / rcar / scu.c

/*
 * Renesas R-Car SCU support
 *
 * Copyright (C) 2013 Renesas Solutions Corp.
 * 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"

struct rsnd_scu {
	struct rsnd_scu_platform_info *info; /* rcar_snd.h */
	struct rsnd_mod mod;
	struct clk *clk;
};

#define RSND_SCU_NAME_SIZE 16

/*
 * ADINR
 */
#define OTBL_24		(0 << 16)
#define OTBL_22		(2 << 16)
#define OTBL_20		(4 << 16)
#define OTBL_18		(6 << 16)
#define OTBL_16		(8 << 16)

#define rsnd_scu_mode_flags(p) ((p)->info->flags)
#define rsnd_scu_convert_rate(p) ((p)->info->convert_rate)
#define rsnd_mod_to_scu(_mod)				\
	container_of((_mod), struct rsnd_scu, mod)
#define rsnd_scu_hpbif_is_enable(scu)	\
	(rsnd_scu_mode_flags(scu) & RSND_SCU_USE_HPBIF)
#define rsnd_scu_dma_available(scu) \
	rsnd_dma_available(rsnd_mod_to_dma(&(scu)->mod))

#define for_each_rsnd_scu(pos, priv, i)				\
	for ((i) = 0;						\
	     ((i) < rsnd_scu_nr(priv)) &&			\
	     ((pos) = (struct rsnd_scu *)(priv)->scu + i);	\
	     i++)


/*
 *		image of SRC (Sampling Rate Converter)
 *
 * 96kHz   <-> +-----+	48kHz	+-----+	 48kHz	+-------+
 * 48kHz   <-> | SRC | <------>	| SSI |	<----->	| codec |
 * 44.1kHz <-> +-----+		+-----+		+-------+
 * ...
 *
 */

/*
 * scu.c is caring...
 *
 * Gen1
 *
 * [mem] -> [SRU] -> [SSI]
 *        |--------|
 *
 * Gen2
 *
 * [mem] -> [SCU] -> [SSIU] -> [SSI]
 *        |-----------------|
 */

/*
 *	How to use SRC bypass mode for debugging
 *
 * SRC has bypass mode, and it is useful for debugging.
 * In Gen2 case,
 * SRCm_MODE controls whether SRC is used or not
 * SSI_MODE0 controls whether SSIU which receives SRC data
 * is used or not.
 * Both SRCm_MODE/SSI_MODE0 settings are needed if you use SRC,
 * but SRC bypass mode needs SSI_MODE0 only.
 *
 * This driver request
 * struct rsnd_scu_platform_info {
 *	u32 flags;
 *	u32 convert_rate;
 * }
 *
 * rsnd_scu_hpbif_is_enable() will be true
 * if flags had RSND_SCU_USE_HPBIF,
 * and it controls whether SSIU is used or not.
 *
 * rsnd_scu_convert_rate() indicates
 * above convert_rate, and it controls
 * whether SRC is used or not.
 *
 * ex) doesn't use SRC
 * struct rsnd_scu_platform_info info = {
 *	.flags = 0,
 *	.convert_rate = 0,
 * };
 *
 * ex) uses SRC
 * struct rsnd_scu_platform_info info = {
 *	.flags = RSND_SCU_USE_HPBIF,
 *	.convert_rate = 48000,
 * };
 *
 * ex) uses SRC bypass mode
 * struct rsnd_scu_platform_info info = {
 *	.flags = RSND_SCU_USE_HPBIF,
 *	.convert_rate = 0,
 * };
 *
 */

/*
 *		Gen1/Gen2 common functions
 */
static int rsnd_scu_ssi_mode_init(struct rsnd_mod *mod,
				  struct rsnd_dai *rdai,
				  struct rsnd_dai_stream *io)
{
	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
	struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io);
	int ssi_id = rsnd_mod_id(ssi_mod);
	u32 convert_rate = rsnd_scu_convert_rate(scu);

	if (convert_rate && !rsnd_dai_is_clk_master(rdai)) {
		struct device *dev = rsnd_priv_to_dev(priv);

		dev_err(dev, "rsnd should be clk master when you rate convert\n");
		return -EINVAL;
	}

	/*
	 * SSI_MODE0
	 */
	rsnd_mod_bset(mod, SSI_MODE0, (1 << ssi_id),
		      rsnd_scu_hpbif_is_enable(scu) ? 0 : (1 << ssi_id));

	/*
	 * SSI_MODE1
	 */
	if (rsnd_ssi_is_pin_sharing(ssi_mod)) {
		int shift = -1;
		switch (ssi_id) {
		case 1:
			shift = 0;
			break;
		case 2:
			shift = 2;
			break;
		case 4:
			shift = 16;
			break;
		}

		if (shift >= 0)
			rsnd_mod_bset(mod, SSI_MODE1,
				      0x3 << shift,
				      rsnd_dai_is_clk_master(rdai) ?
				      0x2 << shift : 0x1 << shift);
	}

	return 0;
}

unsigned int rsnd_scu_get_ssi_rate(struct rsnd_priv *priv,
				   struct rsnd_dai_stream *io,
				   struct snd_pcm_runtime *runtime)
{
	struct rsnd_scu *scu;
	unsigned int rate;

	scu = rsnd_mod_to_scu(rsnd_io_to_mod_scu(io));

	/*
	 * return convert rate if SRC is used,
	 * otherwise, return runtime->rate as usual
	 */
	rate = rsnd_scu_convert_rate(scu);
	if (!rate)
		rate = runtime->rate;

	return rate;
}

static int rsnd_scu_set_convert_rate(struct rsnd_mod *mod,
				     struct rsnd_dai *rdai,
				     struct rsnd_dai_stream *io)
{
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
	u32 convert_rate = rsnd_scu_convert_rate(scu);
	u32 adinr = runtime->channels;
	u32 fsrate = 0;

	if (convert_rate)
		fsrate = 0x0400000 / convert_rate * runtime->rate;

	/* set/clear soft reset */
	rsnd_mod_write(mod, SRC_SWRSR, 0);
	rsnd_mod_write(mod, SRC_SWRSR, 1);

	/*
	 * Initialize the operation of the SRC internal circuits
	 * see rsnd_scu_start()
	 */
	rsnd_mod_write(mod, SRC_SRCIR, 1);

	/* Set channel number and output bit length */
	switch (runtime->sample_bits) {
	case 16:
		adinr |= OTBL_16;
		break;
	case 32:
		adinr |= OTBL_24;
		break;
	default:
		return -EIO;
	}
	rsnd_mod_write(mod, SRC_ADINR, adinr);

	/* Enable the initial value of IFS */
	if (fsrate) {
		rsnd_mod_write(mod, SRC_IFSCR, 1);

		/* Set initial value of IFS */
		rsnd_mod_write(mod, SRC_IFSVR, fsrate);
	}

	/* use DMA transfer */
	rsnd_mod_write(mod, SRC_BUSIF_MODE, 1);

	return 0;
}

static int rsnd_scu_init(struct rsnd_mod *mod,
			 struct rsnd_dai *rdai,
			 struct rsnd_dai_stream *io)
{
	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
	int ret;

	clk_enable(scu->clk);

	ret = rsnd_scu_ssi_mode_init(mod, rdai, io);
	if (ret < 0)
		return ret;

	return 0;
}

static int rsnd_scu_quit(struct rsnd_mod *mod,
			 struct rsnd_dai *rdai,
			 struct rsnd_dai_stream *io)
{
	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);

	clk_disable(scu->clk);

	return 0;
}

static int rsnd_scu_start(struct rsnd_mod *mod,
			  struct rsnd_dai *rdai,
			  struct rsnd_dai_stream *io)
{
	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);

	/*
	 * Cancel the initialization and operate the SRC function
	 * see rsnd_scu_set_convert_rate()
	 */
	rsnd_mod_write(mod, SRC_SRCIR, 0);

	if (rsnd_scu_convert_rate(scu))
		rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);

	return 0;
}


static int rsnd_scu_stop(struct rsnd_mod *mod,
			 struct rsnd_dai *rdai,
			 struct rsnd_dai_stream *io)
{
	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);

	if (rsnd_scu_convert_rate(scu))
		rsnd_mod_write(mod, SRC_ROUTE_MODE0, 0);

	return 0;
}

static struct rsnd_mod_ops rsnd_scu_non_ops = {
	.name	= "scu (non)",
};

/*
 *		Gen1 functions
 */
static int rsnd_src_set_route_gen1(struct rsnd_mod *mod,
				   struct rsnd_dai *rdai,
				   struct rsnd_dai_stream *io)
{
	struct scu_route_config {
		u32 mask;
		int shift;
	} routes[] = {
		{ 0xF,  0, }, /* 0 */
		{ 0xF,  4, }, /* 1 */
		{ 0xF,  8, }, /* 2 */
		{ 0x7, 12, }, /* 3 */
		{ 0x7, 16, }, /* 4 */
		{ 0x7, 20, }, /* 5 */
		{ 0x7, 24, }, /* 6 */
		{ 0x3, 28, }, /* 7 */
		{ 0x3, 30, }, /* 8 */
	};
	u32 mask;
	u32 val;
	int id;

	id = rsnd_mod_id(mod);
	if (id < 0 || id >= ARRAY_SIZE(routes))
		return -EIO;

	/*
	 * SRC_ROUTE_SELECT
	 */
	val = rsnd_dai_is_play(rdai, io) ? 0x1 : 0x2;
	val = val		<< routes[id].shift;
	mask = routes[id].mask	<< routes[id].shift;

	rsnd_mod_bset(mod, SRC_ROUTE_SEL, mask, val);

	return 0;
}

static int rsnd_scu_set_convert_timing_gen1(struct rsnd_mod *mod,
					    struct rsnd_dai *rdai,
					    struct rsnd_dai_stream *io)
{
	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
	u32 convert_rate = rsnd_scu_convert_rate(scu);
	u32 mask;
	u32 val;
	int shift;
	int id = rsnd_mod_id(mod);
	int ret;

	/*
	 * SRC_TIMING_SELECT
	 */
	shift	= (id % 4) * 8;
	mask	= 0x1F << shift;

	/*
	 * ADG is used as source clock if SRC was used,
	 * then, SSI WS is used as destination clock.
	 * SSI WS is used as source clock if SRC is not used
	 * (when playback, source/destination become reverse when capture)
	 */
	ret = 0;
	if (convert_rate) {
		/* use ADG */
		val = 0;
		ret = rsnd_adg_set_convert_clk_gen1(priv, mod,
						    runtime->rate,
						    convert_rate);
	} else if (8 == id) {
		/* use SSI WS, but SRU8 is special */
		val = id << shift;
	} else {
		/* use SSI WS */
		val = (id + 1) << shift;
	}

	if (ret < 0)
		return ret;

	switch (id / 4) {
	case 0:
		rsnd_mod_bset(mod, SRC_TMG_SEL0, mask, val);
		break;
	case 1:
		rsnd_mod_bset(mod, SRC_TMG_SEL1, mask, val);
		break;
	case 2:
		rsnd_mod_bset(mod, SRC_TMG_SEL2, mask, val);
		break;
	}

	return 0;
}

static int rsnd_scu_set_convert_rate_gen1(struct rsnd_mod *mod,
					  struct rsnd_dai *rdai,
					  struct rsnd_dai_stream *io)
{
	int ret;

	ret = rsnd_scu_set_convert_rate(mod, rdai, io);
	if (ret < 0)
		return ret;

	/* Select SRC mode (fixed value) */
	rsnd_mod_write(mod, SRC_SRCCR, 0x00010110);

	/* Set the restriction value of the FS ratio (98%) */
	rsnd_mod_write(mod, SRC_MNFSR,
		       rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98);

	/* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */

	return 0;
}

static int rsnd_scu_init_gen1(struct rsnd_mod *mod,
			      struct rsnd_dai *rdai,
			      struct rsnd_dai_stream *io)
{
	int ret;

	ret = rsnd_scu_init(mod, rdai, io);
	if (ret < 0)
		return ret;

	ret = rsnd_src_set_route_gen1(mod, rdai, io);
	if (ret < 0)
		return ret;

	ret = rsnd_scu_set_convert_rate_gen1(mod, rdai, io);
	if (ret < 0)
		return ret;

	ret = rsnd_scu_set_convert_timing_gen1(mod, rdai, io);
	if (ret < 0)
		return ret;

	return 0;
}

static int rsnd_scu_start_gen1(struct rsnd_mod *mod,
			       struct rsnd_dai *rdai,
			       struct rsnd_dai_stream *io)
{
	int id = rsnd_mod_id(mod);

	rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id));

	return rsnd_scu_start(mod, rdai, io);
}

static int rsnd_scu_stop_gen1(struct rsnd_mod *mod,
			      struct rsnd_dai *rdai,
			      struct rsnd_dai_stream *io)
{
	int id = rsnd_mod_id(mod);

	rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0);

	return rsnd_scu_stop(mod, rdai, io);
}

static struct rsnd_mod_ops rsnd_scu_gen1_ops = {
	.name	= "sru (gen1)",
	.init	= rsnd_scu_init_gen1,
	.quit	= rsnd_scu_quit,
	.start	= rsnd_scu_start_gen1,
	.stop	= rsnd_scu_stop_gen1,
};

static struct rsnd_mod_ops rsnd_scu_non_gen1_ops = {
	.name	= "non-sru (gen1)",
	.init	= rsnd_scu_ssi_mode_init,
};

/*
 *		Gen2 functions
 */
static int rsnd_scu_set_convert_rate_gen2(struct rsnd_mod *mod,
					  struct rsnd_dai *rdai,
					  struct rsnd_dai_stream *io)
{
	int ret;

	ret = rsnd_scu_set_convert_rate(mod, rdai, io);
	if (ret < 0)
		return ret;

	rsnd_mod_write(mod, SSI_BUSIF_ADINR, rsnd_mod_read(mod, SRC_ADINR));
	rsnd_mod_write(mod, SSI_BUSIF_MODE,  rsnd_mod_read(mod, SRC_BUSIF_MODE));

	rsnd_mod_write(mod, SRC_SRCCR, 0x00011110);

	rsnd_mod_write(mod, SRC_BSDSR, 0x01800000);
	rsnd_mod_write(mod, SRC_BSISR, 0x00100060);

	return 0;
}

static int rsnd_scu_set_convert_timing_gen2(struct rsnd_mod *mod,
					    struct rsnd_dai *rdai,
					    struct rsnd_dai_stream *io)
{
	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
	u32 convert_rate = rsnd_scu_convert_rate(scu);
	int ret;

	if (convert_rate)
		ret = rsnd_adg_set_convert_clk_gen2(mod, rdai, io,
						    runtime->rate,
						    convert_rate);
	else
		ret = rsnd_adg_set_convert_timing_gen2(mod, rdai, io);

	return ret;
}

static int rsnd_scu_init_gen2(struct rsnd_mod *mod,
			      struct rsnd_dai *rdai,
			      struct rsnd_dai_stream *io)
{
	int ret;

	ret = rsnd_scu_init(mod, rdai, io);
	if (ret < 0)
		return ret;

	ret = rsnd_scu_set_convert_rate_gen2(mod, rdai, io);
	if (ret < 0)
		return ret;

	ret = rsnd_scu_set_convert_timing_gen2(mod, rdai, io);
	if (ret < 0)
		return ret;

	return 0;
}

static int rsnd_scu_start_gen2(struct rsnd_mod *mod,
			       struct rsnd_dai *rdai,
			       struct rsnd_dai_stream *io)
{
	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);

	rsnd_dma_start(rsnd_mod_to_dma(&scu->mod));

	rsnd_mod_write(mod, SSI_CTRL, 0x1);
	rsnd_mod_write(mod, SRC_CTRL, 0x11);

	return rsnd_scu_start(mod, rdai, io);
}

static int rsnd_scu_stop_gen2(struct rsnd_mod *mod,
			      struct rsnd_dai *rdai,
			      struct rsnd_dai_stream *io)
{
	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);

	rsnd_mod_write(mod, SSI_CTRL, 0);
	rsnd_mod_write(mod, SRC_CTRL, 0);

	rsnd_dma_stop(rsnd_mod_to_dma(&scu->mod));

	return rsnd_scu_stop(mod, rdai, io);
}

static struct rsnd_mod_ops rsnd_scu_gen2_ops = {
	.name	= "scu (gen2)",
	.init	= rsnd_scu_init_gen2,
	.quit	= rsnd_scu_quit,
	.start	= rsnd_scu_start_gen2,
	.stop	= rsnd_scu_stop_gen2,
};

static int rsnd_scu_start_non_gen2(struct rsnd_mod *mod,
				   struct rsnd_dai *rdai,
				   struct rsnd_dai_stream *io)
{
	struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io);

	/* enable PIO interrupt */
	rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0f000000);

	return 0;
}

static struct rsnd_mod_ops rsnd_scu_non_gen2_ops = {
	.name	= "non-scu (gen2)",
	.init	= rsnd_scu_ssi_mode_init,
	.start	= rsnd_scu_start_non_gen2,
};

struct rsnd_mod *rsnd_scu_mod_get(struct rsnd_priv *priv, int id)
{
	if (WARN_ON(id < 0 || id >= rsnd_scu_nr(priv)))
		id = 0;

	return &((struct rsnd_scu *)(priv->scu) + id)->mod;
}

int rsnd_scu_probe(struct platform_device *pdev,
		   struct rsnd_priv *priv)
{
	struct rcar_snd_info *info = rsnd_priv_to_info(priv);
	struct device *dev = rsnd_priv_to_dev(priv);
	struct rsnd_scu *scu;
	struct rsnd_mod_ops *ops;
	struct clk *clk;
	char name[RSND_SCU_NAME_SIZE];
	int i, nr;

	/*
	 * init SCU
	 */
	nr	= info->scu_info_nr;
	scu	= devm_kzalloc(dev, sizeof(*scu) * nr, GFP_KERNEL);
	if (!scu) {
		dev_err(dev, "SCU allocate failed\n");
		return -ENOMEM;
	}

	priv->scu_nr	= nr;
	priv->scu	= scu;

	for_each_rsnd_scu(scu, priv, i) {
		snprintf(name, RSND_SCU_NAME_SIZE, "scu.%d", i);

		clk = devm_clk_get(dev, name);
		if (IS_ERR(clk))
			return PTR_ERR(clk);

		scu->info = &info->scu_info[i];
		scu->clk = clk;

		ops = &rsnd_scu_non_ops;
		if (rsnd_scu_hpbif_is_enable(scu)) {
			if (rsnd_is_gen1(priv))
				ops = &rsnd_scu_gen1_ops;
			if (rsnd_is_gen2(priv)) {
				struct rsnd_mod *ssi = rsnd_ssi_mod_get(priv, i);
				int ret = rsnd_dma_init(priv,
						rsnd_mod_to_dma(&scu->mod),
						rsnd_ssi_is_play(ssi),
						scu->info->dma_id);
				if (ret < 0)
					return ret;

				ops = &rsnd_scu_gen2_ops;
			}
		} else {
			if (rsnd_is_gen1(priv))
				ops = &rsnd_scu_non_gen1_ops;
			if (rsnd_is_gen2(priv))
				ops = &rsnd_scu_non_gen2_ops;
		}

		rsnd_mod_init(priv, &scu->mod, ops, RSND_MOD_SCU, i);

		dev_dbg(dev, "SCU%d probed\n", i);
	}

	return 0;
}

void rsnd_scu_remove(struct platform_device *pdev,
		     struct rsnd_priv *priv)
{
	struct rsnd_scu *scu;
	int i;

	for_each_rsnd_scu(scu, priv, i) {
		if (rsnd_scu_dma_available(scu))
			rsnd_dma_quit(priv, rsnd_mod_to_dma(&scu->mod));
	}
}
Commit	Line	Data
07539c1d KM	1	/*
	2	* Renesas R-Car SCU support
	3	*
	4	* Copyright (C) 2013 Renesas Solutions Corp.
	5	* Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11	#include "rsnd.h"
	12
	13	struct rsnd_scu {
	14	struct rsnd_scu_platform_info info; / rcar_snd.h */
	15	struct rsnd_mod mod;
ef749400	16	struct clk *clk;
07539c1d KM	17	};
07539c1d KM	18
ef749400	19	#define RSND_SCU_NAME_SIZE 16
374a5281 KM	20
	21	/*
	22	* ADINR
	23	*/
	24	#define OTBL_24 (0 << 16)
	25	#define OTBL_22 (2 << 16)
	26	#define OTBL_20 (4 << 16)
	27	#define OTBL_18 (6 << 16)
	28	#define OTBL_16 (8 << 16)
	29
39cf3c40 KM	30	#define rsnd_scu_mode_flags(p) ((p)->info->flags)
	31	#define rsnd_scu_convert_rate(p) ((p)->info->convert_rate)
	32	#define rsnd_mod_to_scu(_mod) \
	33	container_of((_mod), struct rsnd_scu, mod)
96c7c0d6 KM	34	#define rsnd_scu_hpbif_is_enable(scu) \
96c7c0d6 KM	35	(rsnd_scu_mode_flags(scu) & RSND_SCU_USE_HPBIF)
629509c5 KM	36	#define rsnd_scu_dma_available(scu) \
629509c5 KM	37	rsnd_dma_available(rsnd_mod_to_dma(&(scu)->mod))
39cf3c40 KM	38
	39	#define for_each_rsnd_scu(pos, priv, i) \
	40	for ((i) = 0; \
	41	((i) < rsnd_scu_nr(priv)) && \
	42	((pos) = (struct rsnd_scu *)(priv)->scu + i); \
	43	i++)
	44
	45
ef749400 KM	46	/*
	47	* image of SRC (Sampling Rate Converter)
	48	*
	49	* 96kHz <-> +-----+ 48kHz +-----+ 48kHz +-------+
	50	* 48kHz <-> \| SRC \| <------> \| SSI \| <-----> \| codec \|
	51	* 44.1kHz <-> +-----+ +-----+ +-------+
	52	* ...
	53	*
	54	*/
374a5281	55
c926b746 KM	56	/*
	57	* scu.c is caring...
	58	*
	59	* Gen1
	60	*
	61	* [mem] -> [SRU] -> [SSI]
	62	* \|--------\|
	63	*
	64	* Gen2
	65	*
	66	* [mem] -> [SCU] -> [SSIU] -> [SSI]
	67	* \|-----------------\|
	68	*/
	69
41c6221c KM	70	/*
	71	* How to use SRC bypass mode for debugging
	72	*
	73	* SRC has bypass mode, and it is useful for debugging.
	74	* In Gen2 case,
	75	* SRCm_MODE controls whether SRC is used or not
	76	* SSI_MODE0 controls whether SSIU which receives SRC data
	77	* is used or not.
	78	* Both SRCm_MODE/SSI_MODE0 settings are needed if you use SRC,
	79	* but SRC bypass mode needs SSI_MODE0 only.
	80	*
	81	* This driver request
	82	* struct rsnd_scu_platform_info {
	83	* u32 flags;
	84	* u32 convert_rate;
	85	* }
	86	*
	87	* rsnd_scu_hpbif_is_enable() will be true
	88	* if flags had RSND_SCU_USE_HPBIF,
	89	* and it controls whether SSIU is used or not.
	90	*
	91	* rsnd_scu_convert_rate() indicates
	92	* above convert_rate, and it controls
	93	* whether SRC is used or not.
	94	*
	95	* ex) doesn't use SRC
	96	* struct rsnd_scu_platform_info info = {
	97	* .flags = 0,
	98	* .convert_rate = 0,
	99	* };
	100	*
	101	* ex) uses SRC
	102	* struct rsnd_scu_platform_info info = {
	103	* .flags = RSND_SCU_USE_HPBIF,
	104	* .convert_rate = 48000,
	105	* };
	106	*
	107	* ex) uses SRC bypass mode
	108	* struct rsnd_scu_platform_info info = {
	109	* .flags = RSND_SCU_USE_HPBIF,
	110	* .convert_rate = 0,
	111	* };
	112	*
	113	*/
	114
1b7b08ef KM	115	/*
	116	* Gen1/Gen2 common functions
	117	*/
7b5ce975 KM	118	static int rsnd_scu_ssi_mode_init(struct rsnd_mod *mod,
	119	struct rsnd_dai *rdai,
	120	struct rsnd_dai_stream *io)
	121	{
	122	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
96c7c0d6	123	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
374e5426 KM	124	struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io);
374e5426 KM	125	int ssi_id = rsnd_mod_id(ssi_mod);
a2070fee KM	126	u32 convert_rate = rsnd_scu_convert_rate(scu);
	127
	128	if (convert_rate && !rsnd_dai_is_clk_master(rdai)) {
	129	struct device *dev = rsnd_priv_to_dev(priv);
	130
	131	dev_err(dev, "rsnd should be clk master when you rate convert\n");
	132	return -EINVAL;
	133	}
7b5ce975 KM	134
	135	/*
	136	* SSI_MODE0
	137	*/
374e5426 KM	138	rsnd_mod_bset(mod, SSI_MODE0, (1 << ssi_id),
374e5426 KM	139	rsnd_scu_hpbif_is_enable(scu) ? 0 : (1 << ssi_id));
7b5ce975 KM	140
	141	/*
	142	* SSI_MODE1
	143	*/
374e5426	144	if (rsnd_ssi_is_pin_sharing(ssi_mod)) {
7b5ce975	145	int shift = -1;
374e5426	146	switch (ssi_id) {
7b5ce975 KM	147	case 1:
	148	shift = 0;
	149	break;
	150	case 2:
	151	shift = 2;
	152	break;
	153	case 4:
	154	shift = 16;
	155	break;
	156	}
	157
	158	if (shift >= 0)
	159	rsnd_mod_bset(mod, SSI_MODE1,
	160	0x3 << shift,
	161	rsnd_dai_is_clk_master(rdai) ?
	162	0x2 << shift : 0x1 << shift);
	163	}
	164
	165	return 0;
	166	}
	167
1b7b08ef	168	unsigned int rsnd_scu_get_ssi_rate(struct rsnd_priv *priv,
374e5426	169	struct rsnd_dai_stream *io,
1b7b08ef KM	170	struct snd_pcm_runtime *runtime)
	171	{
	172	struct rsnd_scu *scu;
	173	unsigned int rate;
	174
374e5426	175	scu = rsnd_mod_to_scu(rsnd_io_to_mod_scu(io));
1b7b08ef KM	176
	177	/*
	178	* return convert rate if SRC is used,
	179	* otherwise, return runtime->rate as usual
	180	*/
	181	rate = rsnd_scu_convert_rate(scu);
	182	if (!rate)
	183	rate = runtime->rate;
	184
	185	return rate;
	186	}
	187
	188	static int rsnd_scu_set_convert_rate(struct rsnd_mod *mod,
	189	struct rsnd_dai *rdai,
	190	struct rsnd_dai_stream *io)
	191	{
	192	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
	193	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
	194	u32 convert_rate = rsnd_scu_convert_rate(scu);
	195	u32 adinr = runtime->channels;
	196	u32 fsrate = 0;
	197
	198	if (convert_rate)
	199	fsrate = 0x0400000 / convert_rate * runtime->rate;
	200
	201	/* set/clear soft reset */
	202	rsnd_mod_write(mod, SRC_SWRSR, 0);
	203	rsnd_mod_write(mod, SRC_SWRSR, 1);
	204
	205	/*
	206	* Initialize the operation of the SRC internal circuits
	207	* see rsnd_scu_start()
	208	*/
	209	rsnd_mod_write(mod, SRC_SRCIR, 1);
	210
	211	/* Set channel number and output bit length */
	212	switch (runtime->sample_bits) {
	213	case 16:
	214	adinr \|= OTBL_16;
	215	break;
	216	case 32:
	217	adinr \|= OTBL_24;
	218	break;
	219	default:
	220	return -EIO;
	221	}
	222	rsnd_mod_write(mod, SRC_ADINR, adinr);
	223
	224	/* Enable the initial value of IFS */
	225	if (fsrate) {
	226	rsnd_mod_write(mod, SRC_IFSCR, 1);
	227
	228	/* Set initial value of IFS */
	229	rsnd_mod_write(mod, SRC_IFSVR, fsrate);
	230	}
	231
	232	/* use DMA transfer */
	233	rsnd_mod_write(mod, SRC_BUSIF_MODE, 1);
	234
	235	return 0;
	236	}
	237
	238	static int rsnd_scu_init(struct rsnd_mod *mod,
	239	struct rsnd_dai *rdai,
240	struct rsnd_dai_stream *io)
241	{
242	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
243	int ret;
244
245	clk_enable(scu->clk);
246
247	ret = rsnd_scu_ssi_mode_init(mod, rdai, io);
248	if (ret < 0)
249	return ret;
250
251	return 0;
252	}
253
254	static int rsnd_scu_quit(struct rsnd_mod *mod,
255	struct rsnd_dai *rdai,
256	struct rsnd_dai_stream *io)
257	{
258	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
259
260	clk_disable(scu->clk);
261
262	return 0;
263	}
264
265	static int rsnd_scu_start(struct rsnd_mod *mod,
266	struct rsnd_dai *rdai,
267	struct rsnd_dai_stream *io)
268	{
269	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
270
271	/*
272	* Cancel the initialization and operate the SRC function
273	* see rsnd_scu_set_convert_rate()
274	*/
275	rsnd_mod_write(mod, SRC_SRCIR, 0);
276
277	if (rsnd_scu_convert_rate(scu))
278	rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);
279
280	return 0;
281	}
282
283
284	static int rsnd_scu_stop(struct rsnd_mod *mod,
285	struct rsnd_dai *rdai,
286	struct rsnd_dai_stream *io)
287	{
288	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
289
290	if (rsnd_scu_convert_rate(scu))
291	rsnd_mod_write(mod, SRC_ROUTE_MODE0, 0);
292
293	return 0;
294	}
295
296	static struct rsnd_mod_ops rsnd_scu_non_ops = {
297	.name = "scu (non)",
298	};
299
300	/*
301	* Gen1 functions
302	*/
303	static int rsnd_src_set_route_gen1(struct rsnd_mod *mod,
304	struct rsnd_dai *rdai,
305	struct rsnd_dai_stream *io)
374a5281 KM	306	{
	307	struct scu_route_config {
	308	u32 mask;
	309	int shift;
	310	} routes[] = {
	311	{ 0xF, 0, }, /* 0 */
	312	{ 0xF, 4, }, /* 1 */
	313	{ 0xF, 8, }, /* 2 */
	314	{ 0x7, 12, }, /* 3 */
	315	{ 0x7, 16, }, /* 4 */
	316	{ 0x7, 20, }, /* 5 */
	317	{ 0x7, 24, }, /* 6 */
	318	{ 0x3, 28, }, /* 7 */
	319	{ 0x3, 30, }, /* 8 */
	320	};
374a5281 KM	321	u32 mask;
374a5281 KM	322	u32 val;
374a5281 KM	323	int id;
374a5281 KM	324
374a5281	325	id = rsnd_mod_id(mod);
b5f3d7af	326	if (id < 0 \|\| id >= ARRAY_SIZE(routes))
374a5281 KM	327	return -EIO;
	328
	329	/*
	330	* SRC_ROUTE_SELECT
	331	*/
	332	val = rsnd_dai_is_play(rdai, io) ? 0x1 : 0x2;
	333	val = val << routes[id].shift;
	334	mask = routes[id].mask << routes[id].shift;
	335
	336	rsnd_mod_bset(mod, SRC_ROUTE_SEL, mask, val);
	337
28dc4b63 KM	338	return 0;
	339	}
	340
	341	static int rsnd_scu_set_convert_timing_gen1(struct rsnd_mod *mod,
	342	struct rsnd_dai *rdai,
	343	struct rsnd_dai_stream *io)
	344	{
	345	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
	346	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
	347	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
	348	u32 convert_rate = rsnd_scu_convert_rate(scu);
	349	u32 mask;
	350	u32 val;
	351	int shift;
	352	int id = rsnd_mod_id(mod);
	353	int ret;
	354
374a5281 KM	355	/*
	356	* SRC_TIMING_SELECT
	357	*/
	358	shift = (id % 4) * 8;
	359	mask = 0x1F << shift;
ef749400 KM	360
	361	/*
	362	* ADG is used as source clock if SRC was used,
	363	* then, SSI WS is used as destination clock.
	364	* SSI WS is used as source clock if SRC is not used
	365	* (when playback, source/destination become reverse when capture)
	366	*/
28dc4b63 KM	367	ret = 0;
	368	if (convert_rate) {
	369	/* use ADG */
ef749400	370	val = 0;
28dc4b63 KM	371	ret = rsnd_adg_set_convert_clk_gen1(priv, mod,
	372	runtime->rate,
	373	convert_rate);
	374	} else if (8 == id) {
	375	/* use SSI WS, but SRU8 is special */
374a5281	376	val = id << shift;
28dc4b63 KM	377	} else {
28dc4b63 KM	378	/* use SSI WS */
374a5281	379	val = (id + 1) << shift;
28dc4b63 KM	380	}
	381
	382	if (ret < 0)
	383	return ret;
374a5281 KM	384
	385	switch (id / 4) {
	386	case 0:
	387	rsnd_mod_bset(mod, SRC_TMG_SEL0, mask, val);
	388	break;
	389	case 1:
	390	rsnd_mod_bset(mod, SRC_TMG_SEL1, mask, val);
	391	break;
	392	case 2:
	393	rsnd_mod_bset(mod, SRC_TMG_SEL2, mask, val);
	394	break;
	395	}
	396
	397	return 0;
	398	}
	399
1b7b08ef KM	400	static int rsnd_scu_set_convert_rate_gen1(struct rsnd_mod *mod,
	401	struct rsnd_dai *rdai,
	402	struct rsnd_dai_stream *io)
374a5281	403	{
1b7b08ef	404	int ret;
ef749400	405
1b7b08ef KM	406	ret = rsnd_scu_set_convert_rate(mod, rdai, io);
	407	if (ret < 0)
	408	return ret;
ef749400	409
1b7b08ef KM	410	/* Select SRC mode (fixed value) */
1b7b08ef KM	411	rsnd_mod_write(mod, SRC_SRCCR, 0x00010110);
ef749400	412
1b7b08ef KM	413	/* Set the restriction value of the FS ratio (98%) */
	414	rsnd_mod_write(mod, SRC_MNFSR,
	415	rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98);
ef749400	416
1b7b08ef	417	/* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */
ef749400	418
374a5281 KM	419	return 0;
	420	}
	421
1b7b08ef KM	422	static int rsnd_scu_init_gen1(struct rsnd_mod *mod,
	423	struct rsnd_dai *rdai,
	424	struct rsnd_dai_stream *io)
07539c1d	425	{
374a5281 KM	426	int ret;
374a5281 KM	427
1b7b08ef	428	ret = rsnd_scu_init(mod, rdai, io);
7b5ce975 KM	429	if (ret < 0)
	430	return ret;
	431
1b7b08ef	432	ret = rsnd_src_set_route_gen1(mod, rdai, io);
374a5281 KM	433	if (ret < 0)
	434	return ret;
	435
1b7b08ef	436	ret = rsnd_scu_set_convert_rate_gen1(mod, rdai, io);
374a5281 KM	437	if (ret < 0)
374a5281 KM	438	return ret;
07539c1d	439
28dc4b63 KM	440	ret = rsnd_scu_set_convert_timing_gen1(mod, rdai, io);
	441	if (ret < 0)
	442	return ret;
	443
a204d90c KM	444	return 0;
	445	}
	446
1b7b08ef KM	447	static int rsnd_scu_start_gen1(struct rsnd_mod *mod,
	448	struct rsnd_dai *rdai,
	449	struct rsnd_dai_stream *io)
a204d90c	450	{
1b7b08ef	451	int id = rsnd_mod_id(mod);
a204d90c	452
1b7b08ef	453	rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id));
374a5281	454
1b7b08ef	455	return rsnd_scu_start(mod, rdai, io);
07539c1d KM	456	}
07539c1d KM	457
1b7b08ef KM	458	static int rsnd_scu_stop_gen1(struct rsnd_mod *mod,
	459	struct rsnd_dai *rdai,
	460	struct rsnd_dai_stream *io)
a204d90c	461	{
e7ce74ea	462	int id = rsnd_mod_id(mod);
a204d90c	463
1b7b08ef	464	rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0);
e7ce74ea	465
1b7b08ef	466	return rsnd_scu_stop(mod, rdai, io);
a204d90c KM	467	}
a204d90c KM	468
1b7b08ef KM	469	static struct rsnd_mod_ops rsnd_scu_gen1_ops = {
	470	.name = "sru (gen1)",
	471	.init = rsnd_scu_init_gen1,
	472	.quit = rsnd_scu_quit,
	473	.start = rsnd_scu_start_gen1,
	474	.stop = rsnd_scu_stop_gen1,
	475	};
e7ce74ea	476
1b7b08ef KM	477	static struct rsnd_mod_ops rsnd_scu_non_gen1_ops = {
	478	.name = "non-sru (gen1)",
	479	.init = rsnd_scu_ssi_mode_init,
	480	};
ef749400	481
1b7b08ef KM	482	/*
	483	* Gen2 functions
	484	*/
629509c5 KM	485	static int rsnd_scu_set_convert_rate_gen2(struct rsnd_mod *mod,
	486	struct rsnd_dai *rdai,
	487	struct rsnd_dai_stream *io)
	488	{
	489	int ret;
	490
	491	ret = rsnd_scu_set_convert_rate(mod, rdai, io);
	492	if (ret < 0)
	493	return ret;
	494
	495	rsnd_mod_write(mod, SSI_BUSIF_ADINR, rsnd_mod_read(mod, SRC_ADINR));
	496	rsnd_mod_write(mod, SSI_BUSIF_MODE, rsnd_mod_read(mod, SRC_BUSIF_MODE));
	497
	498	rsnd_mod_write(mod, SRC_SRCCR, 0x00011110);
	499
	500	rsnd_mod_write(mod, SRC_BSDSR, 0x01800000);
	501	rsnd_mod_write(mod, SRC_BSISR, 0x00100060);
	502
	503	return 0;
	504	}
	505
	506	static int rsnd_scu_set_convert_timing_gen2(struct rsnd_mod *mod,
	507	struct rsnd_dai *rdai,
	508	struct rsnd_dai_stream *io)
	509	{
	510	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
	511	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
	512	u32 convert_rate = rsnd_scu_convert_rate(scu);
	513	int ret;
	514
	515	if (convert_rate)
	516	ret = rsnd_adg_set_convert_clk_gen2(mod, rdai, io,
	517	runtime->rate,
	518	convert_rate);
	519	else
	520	ret = rsnd_adg_set_convert_timing_gen2(mod, rdai, io);
	521
	522	return ret;
	523	}
	524
	525	static int rsnd_scu_init_gen2(struct rsnd_mod *mod,
	526	struct rsnd_dai *rdai,
	527	struct rsnd_dai_stream *io)
	528	{
	529	int ret;
	530
	531	ret = rsnd_scu_init(mod, rdai, io);
	532	if (ret < 0)
	533	return ret;
	534
	535	ret = rsnd_scu_set_convert_rate_gen2(mod, rdai, io);
	536	if (ret < 0)
	537	return ret;
	538
	539	ret = rsnd_scu_set_convert_timing_gen2(mod, rdai, io);
	540	if (ret < 0)
	541	return ret;
	542
	543	return 0;
	544	}
	545
	546	static int rsnd_scu_start_gen2(struct rsnd_mod *mod,
	547	struct rsnd_dai *rdai,
	548	struct rsnd_dai_stream *io)
549	{
550	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
551
552	rsnd_dma_start(rsnd_mod_to_dma(&scu->mod));
553
554	rsnd_mod_write(mod, SSI_CTRL, 0x1);
555	rsnd_mod_write(mod, SRC_CTRL, 0x11);
556
557	return rsnd_scu_start(mod, rdai, io);
558	}
559
560	static int rsnd_scu_stop_gen2(struct rsnd_mod *mod,
561	struct rsnd_dai *rdai,
562	struct rsnd_dai_stream *io)
563	{
564	struct rsnd_scu *scu = rsnd_mod_to_scu(mod);
565
566	rsnd_mod_write(mod, SSI_CTRL, 0);
567	rsnd_mod_write(mod, SRC_CTRL, 0);
568
569	rsnd_dma_stop(rsnd_mod_to_dma(&scu->mod));
570
571	return rsnd_scu_stop(mod, rdai, io);
572	}
573
574	static struct rsnd_mod_ops rsnd_scu_gen2_ops = {
575	.name = "scu (gen2)",
576	.init = rsnd_scu_init_gen2,
577	.quit = rsnd_scu_quit,
578	.start = rsnd_scu_start_gen2,
579	.stop = rsnd_scu_stop_gen2,
580	};
581
1b7b08ef KM	582	static int rsnd_scu_start_non_gen2(struct rsnd_mod *mod,
	583	struct rsnd_dai *rdai,
	584	struct rsnd_dai_stream *io)
	585	{
374e5426 KM	586	struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io);
374e5426 KM	587
1b7b08ef	588	/* enable PIO interrupt */
374e5426	589	rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0f000000);
ef749400	590
ef749400 KM	591	return 0;
	592	}
	593
1b7b08ef KM	594	static struct rsnd_mod_ops rsnd_scu_non_gen2_ops = {
1b7b08ef KM	595	.name = "non-scu (gen2)",
7b5ce975	596	.init = rsnd_scu_ssi_mode_init,
1b7b08ef	597	.start = rsnd_scu_start_non_gen2,
013f38fe KM	598	};
013f38fe KM	599
07539c1d KM	600	struct rsnd_mod rsnd_scu_mod_get(struct rsnd_priv priv, int id)
07539c1d KM	601	{
8b14719b TI	602	if (WARN_ON(id < 0 \|\| id >= rsnd_scu_nr(priv)))
8b14719b TI	603	id = 0;
07539c1d KM	604
	605	return &((struct rsnd_scu *)(priv->scu) + id)->mod;
	606	}
	607
	608	int rsnd_scu_probe(struct platform_device *pdev,
07539c1d KM	609	struct rsnd_priv *priv)
07539c1d KM	610	{
5da39cf3	611	struct rcar_snd_info *info = rsnd_priv_to_info(priv);
07539c1d KM	612	struct device *dev = rsnd_priv_to_dev(priv);
07539c1d KM	613	struct rsnd_scu *scu;
013f38fe	614	struct rsnd_mod_ops *ops;
ef749400 KM	615	struct clk *clk;
ef749400 KM	616	char name[RSND_SCU_NAME_SIZE];
07539c1d KM	617	int i, nr;
	618
	619	/*
	620	* init SCU
	621	*/
	622	nr = info->scu_info_nr;
	623	scu = devm_kzalloc(dev, sizeof(scu) nr, GFP_KERNEL);
	624	if (!scu) {
	625	dev_err(dev, "SCU allocate failed\n");
	626	return -ENOMEM;
	627	}
	628
	629	priv->scu_nr = nr;
	630	priv->scu = scu;
	631
	632	for_each_rsnd_scu(scu, priv, i) {
ef749400 KM	633	snprintf(name, RSND_SCU_NAME_SIZE, "scu.%d", i);
	634
	635	clk = devm_clk_get(dev, name);
	636	if (IS_ERR(clk))
	637	return PTR_ERR(clk);
	638
07539c1d	639	scu->info = &info->scu_info[i];
ef749400	640	scu->clk = clk;
07539c1d	641
013f38fe	642	ops = &rsnd_scu_non_ops;
1b7b08ef KM	643	if (rsnd_scu_hpbif_is_enable(scu)) {
	644	if (rsnd_is_gen1(priv))
	645	ops = &rsnd_scu_gen1_ops;
629509c5 KM	646	if (rsnd_is_gen2(priv)) {
	647	struct rsnd_mod *ssi = rsnd_ssi_mod_get(priv, i);
	648	int ret = rsnd_dma_init(priv,
	649	rsnd_mod_to_dma(&scu->mod),
	650	rsnd_ssi_is_play(ssi),
	651	scu->info->dma_id);
	652	if (ret < 0)
	653	return ret;
	654
	655	ops = &rsnd_scu_gen2_ops;
	656	}
1b7b08ef KM	657	} else {
	658	if (rsnd_is_gen1(priv))
	659	ops = &rsnd_scu_non_gen1_ops;
	660	if (rsnd_is_gen2(priv))
	661	ops = &rsnd_scu_non_gen2_ops;
	662	}
013f38fe	663
a126021d	664	rsnd_mod_init(priv, &scu->mod, ops, RSND_MOD_SCU, i);
013f38fe	665
374a5281 KM	666	dev_dbg(dev, "SCU%d probed\n", i);
374a5281 KM	667	}
07539c1d KM	668
	669	return 0;
	670	}
	671
	672	void rsnd_scu_remove(struct platform_device *pdev,
	673	struct rsnd_priv *priv)
	674	{
629509c5 KM	675	struct rsnd_scu *scu;
	676	int i;
	677
	678	for_each_rsnd_scu(scu, priv, i) {
	679	if (rsnd_scu_dma_available(scu))
	680	rsnd_dma_quit(priv, rsnd_mod_to_dma(&scu->mod));
	681	}
07539c1d	682	}