[deliverable/linux.git] / sound / soc / sh / rcar / gen.c

/*
 * Renesas R-Car Gen1 SRU/SSI 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_gen_ops {
	int (*path_init)(struct rsnd_priv *priv,
			 struct rsnd_dai *rdai,
			 struct rsnd_dai_stream *io);
	int (*path_exit)(struct rsnd_priv *priv,
			 struct rsnd_dai *rdai,
			 struct rsnd_dai_stream *io);
};

struct rsnd_gen_reg_map {
	int index;	/* -1 : not supported */
	u32 offset_id;	/* offset of ssi0, ssi1, ssi2... */
	u32 offset_adr;	/* offset of SSICR, SSISR, ... */
};

struct rsnd_gen {
	void __iomem *base[RSND_BASE_MAX];

	struct rsnd_gen_reg_map reg_map[RSND_REG_MAX];
	struct rsnd_gen_ops *ops;
};

#define rsnd_priv_to_gen(p)	((struct rsnd_gen *)(p)->gen)

#define rsnd_is_gen1(s)		((s)->info->flags & RSND_GEN1)
#define rsnd_is_gen2(s)		((s)->info->flags & RSND_GEN2)

/*
 *		Gen2
 *		will be filled in the future
 */

/*
 *		Gen1
 */
static int rsnd_gen1_path_init(struct rsnd_priv *priv,
			       struct rsnd_dai *rdai,
			       struct rsnd_dai_stream *io)
{
	struct rsnd_dai_platform_info *info = rsnd_dai_get_platform_info(rdai);
	struct rsnd_mod *mod;
	int ret;
	int id;

	/*
	 * Gen1 is created by SRU/SSI, and this SRU is base module of
	 * Gen2's SCU/SSIU/SSI. (Gen2 SCU/SSIU came from SRU)
	 *
	 * Easy image is..
	 *	Gen1 SRU = Gen2 SCU + SSIU + etc
	 *
	 * Gen2 SCU path is very flexible, but, Gen1 SRU (SCU parts) is
	 * using fixed path.
	 *
	 * Then, SSI id = SCU id here
	 */

	if (rsnd_dai_is_play(rdai, io))
		id = info->ssi_id_playback;
	else
		id = info->ssi_id_capture;

	/* SSI */
	mod = rsnd_ssi_mod_get(priv, id);
	ret = rsnd_dai_connect(rdai, mod, io);
	if (ret < 0)
		return ret;

	/* SCU */
	mod = rsnd_scu_mod_get(priv, id);
	ret = rsnd_dai_connect(rdai, mod, io);

	return ret;
}

static int rsnd_gen1_path_exit(struct rsnd_priv *priv,
			       struct rsnd_dai *rdai,
			       struct rsnd_dai_stream *io)
{
	struct rsnd_mod *mod, *n;
	int ret = 0;

	/*
	 * remove all mod from rdai
	 */
	for_each_rsnd_mod(mod, n, io)
		ret |= rsnd_dai_disconnect(mod);

	return ret;
}

static struct rsnd_gen_ops rsnd_gen1_ops = {
	.path_init	= rsnd_gen1_path_init,
	.path_exit	= rsnd_gen1_path_exit,
};

#define RSND_GEN1_REG_MAP(g, s, i, oi, oa)				\
	do {								\
		(g)->reg_map[RSND_REG_##i].index  = RSND_GEN1_##s;	\
		(g)->reg_map[RSND_REG_##i].offset_id = oi;		\
		(g)->reg_map[RSND_REG_##i].offset_adr = oa;		\
	} while (0)

static void rsnd_gen1_reg_map_init(struct rsnd_gen *gen)
{
	RSND_GEN1_REG_MAP(gen, SRU,	SSI_MODE0,	0x0,	0xD0);
	RSND_GEN1_REG_MAP(gen, SRU,	SSI_MODE1,	0x0,	0xD4);

	RSND_GEN1_REG_MAP(gen, ADG,	BRRA,		0x0,	0x00);
	RSND_GEN1_REG_MAP(gen, ADG,	BRRB,		0x0,	0x04);
	RSND_GEN1_REG_MAP(gen, ADG,	SSICKR,		0x0,	0x08);
	RSND_GEN1_REG_MAP(gen, ADG,	AUDIO_CLK_SEL0,	0x0,	0x0c);
	RSND_GEN1_REG_MAP(gen, ADG,	AUDIO_CLK_SEL1,	0x0,	0x10);
	RSND_GEN1_REG_MAP(gen, ADG,	AUDIO_CLK_SEL3,	0x0,	0x18);
	RSND_GEN1_REG_MAP(gen, ADG,	AUDIO_CLK_SEL4,	0x0,	0x1c);
	RSND_GEN1_REG_MAP(gen, ADG,	AUDIO_CLK_SEL5,	0x0,	0x20);

	RSND_GEN1_REG_MAP(gen, SSI,	SSICR,		0x40,	0x00);
	RSND_GEN1_REG_MAP(gen, SSI,	SSISR,		0x40,	0x04);
	RSND_GEN1_REG_MAP(gen, SSI,	SSITDR,		0x40,	0x08);
	RSND_GEN1_REG_MAP(gen, SSI,	SSIRDR,		0x40,	0x0c);
	RSND_GEN1_REG_MAP(gen, SSI,	SSIWSR,		0x40,	0x20);
}

static int rsnd_gen1_probe(struct platform_device *pdev,
			   struct rcar_snd_info *info,
			   struct rsnd_priv *priv)
{
	struct device *dev = rsnd_priv_to_dev(priv);
	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
	struct resource *sru_res;
	struct resource *adg_res;
	struct resource *ssi_res;

	/*
	 * map address
	 */
	sru_res	= platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_SRU);
	adg_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_ADG);
	ssi_res	= platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_SSI);
	if (!sru_res ||
	    !adg_res ||
	    !ssi_res) {
		dev_err(dev, "Not enough SRU/SSI/ADG platform resources.\n");
		return -ENODEV;
	}

	gen->ops = &rsnd_gen1_ops;

	gen->base[RSND_GEN1_SRU] = devm_ioremap_resource(dev, sru_res);
	gen->base[RSND_GEN1_ADG] = devm_ioremap_resource(dev, adg_res);
	gen->base[RSND_GEN1_SSI] = devm_ioremap_resource(dev, ssi_res);
	if (!gen->base[RSND_GEN1_SRU] ||
	    !gen->base[RSND_GEN1_ADG] ||
	    !gen->base[RSND_GEN1_SSI]) {
		dev_err(dev, "SRU/SSI/ADG ioremap failed\n");
		return -ENODEV;
	}

	rsnd_gen1_reg_map_init(gen);

	dev_dbg(dev, "Gen1 device probed\n");
	dev_dbg(dev, "SRU : %08x => %p\n",	sru_res->start,
						gen->base[RSND_GEN1_SRU]);
	dev_dbg(dev, "ADG : %08x => %p\n",	adg_res->start,
						gen->base[RSND_GEN1_ADG]);
	dev_dbg(dev, "SSI : %08x => %p\n",	ssi_res->start,
						gen->base[RSND_GEN1_SSI]);

	return 0;

}

static void rsnd_gen1_remove(struct platform_device *pdev,
			     struct rsnd_priv *priv)
{
}

/*
 *		Gen
 */
int rsnd_gen_path_init(struct rsnd_priv *priv,
		       struct rsnd_dai *rdai,
		       struct rsnd_dai_stream *io)
{
	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);

	return gen->ops->path_init(priv, rdai, io);
}

int rsnd_gen_path_exit(struct rsnd_priv *priv,
		       struct rsnd_dai *rdai,
		       struct rsnd_dai_stream *io)
{
	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);

	return gen->ops->path_exit(priv, rdai, io);
}

void __iomem *rsnd_gen_reg_get(struct rsnd_priv *priv,
			       struct rsnd_mod *mod,
			       enum rsnd_reg reg)
{
	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
	struct device *dev = rsnd_priv_to_dev(priv);
	int index;
	u32 offset_id, offset_adr;

	if (reg >= RSND_REG_MAX) {
		dev_err(dev, "rsnd_reg reg error\n");
		return NULL;
	}

	index		= gen->reg_map[reg].index;
	offset_id	= gen->reg_map[reg].offset_id;
	offset_adr	= gen->reg_map[reg].offset_adr;

	if (index < 0) {
		dev_err(dev, "unsupported reg access %d\n", reg);
		return NULL;
	}

	if (offset_id && mod)
		offset_id *= rsnd_mod_id(mod);

	/*
	 * index/offset were set on gen1/gen2
	 */

	return gen->base[index] + offset_id + offset_adr;
}

int rsnd_gen_probe(struct platform_device *pdev,
		   struct rcar_snd_info *info,
		   struct rsnd_priv *priv)
{
	struct device *dev = rsnd_priv_to_dev(priv);
	struct rsnd_gen *gen;
	int i;

	gen = devm_kzalloc(dev, sizeof(*gen), GFP_KERNEL);
	if (!gen) {
		dev_err(dev, "GEN allocate failed\n");
		return -ENOMEM;
	}

	priv->gen = gen;

	/*
	 * see
	 *	rsnd_reg_get()
	 *	rsnd_gen_probe()
	 */
	for (i = 0; i < RSND_REG_MAX; i++)
		gen->reg_map[i].index = -1;

	/*
	 *	init each module
	 */
	if (rsnd_is_gen1(priv))
		return rsnd_gen1_probe(pdev, info, priv);

	dev_err(dev, "unknown generation R-Car sound device\n");

	return -ENODEV;
}

void rsnd_gen_remove(struct platform_device *pdev,
		     struct rsnd_priv *priv)
{
	if (rsnd_is_gen1(priv))
		rsnd_gen1_remove(pdev, priv);
}
Commit	Line	Data
3337744a KM	1	/*
	2	* Renesas R-Car Gen1 SRU/SSI 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_gen_ops {
	14	int (path_init)(struct rsnd_priv priv,
	15	struct rsnd_dai *rdai,
	16	struct rsnd_dai_stream *io);
	17	int (path_exit)(struct rsnd_priv priv,
	18	struct rsnd_dai *rdai,
	19	struct rsnd_dai_stream *io);
	20	};
	21
	22	struct rsnd_gen_reg_map {
	23	int index; /* -1 : not supported */
	24	u32 offset_id; /* offset of ssi0, ssi1, ssi2... */
	25	u32 offset_adr; /* offset of SSICR, SSISR, ... */
	26	};
	27
	28	struct rsnd_gen {
	29	void __iomem *base[RSND_BASE_MAX];
	30
	31	struct rsnd_gen_reg_map reg_map[RSND_REG_MAX];
	32	struct rsnd_gen_ops *ops;
	33	};
	34
	35	#define rsnd_priv_to_gen(p) ((struct rsnd_gen *)(p)->gen)
	36
	37	#define rsnd_is_gen1(s) ((s)->info->flags & RSND_GEN1)
	38	#define rsnd_is_gen2(s) ((s)->info->flags & RSND_GEN2)
	39
	40	/*
	41	* Gen2
	42	* will be filled in the future
	43	*/
	44
	45	/*
	46	* Gen1
	47	*/
07539c1d KM	48	static int rsnd_gen1_path_init(struct rsnd_priv *priv,
	49	struct rsnd_dai *rdai,
	50	struct rsnd_dai_stream *io)
	51	{
	52	struct rsnd_dai_platform_info *info = rsnd_dai_get_platform_info(rdai);
	53	struct rsnd_mod *mod;
	54	int ret;
	55	int id;
	56
	57	/*
	58	* Gen1 is created by SRU/SSI, and this SRU is base module of
	59	* Gen2's SCU/SSIU/SSI. (Gen2 SCU/SSIU came from SRU)
	60	*
	61	* Easy image is..
	62	* Gen1 SRU = Gen2 SCU + SSIU + etc
	63	*
	64	* Gen2 SCU path is very flexible, but, Gen1 SRU (SCU parts) is
	65	* using fixed path.
	66	*
	67	* Then, SSI id = SCU id here
	68	*/
	69
	70	if (rsnd_dai_is_play(rdai, io))
	71	id = info->ssi_id_playback;
	72	else
	73	id = info->ssi_id_capture;
	74
ae5c3223 KM	75	/* SSI */
	76	mod = rsnd_ssi_mod_get(priv, id);
	77	ret = rsnd_dai_connect(rdai, mod, io);
	78	if (ret < 0)
	79	return ret;
	80
07539c1d KM	81	/* SCU */
	82	mod = rsnd_scu_mod_get(priv, id);
	83	ret = rsnd_dai_connect(rdai, mod, io);
	84
	85	return ret;
	86	}
	87
	88	static int rsnd_gen1_path_exit(struct rsnd_priv *priv,
	89	struct rsnd_dai *rdai,
	90	struct rsnd_dai_stream *io)
	91	{
	92	struct rsnd_mod mod, n;
	93	int ret = 0;
	94
	95	/*
	96	* remove all mod from rdai
	97	*/
	98	for_each_rsnd_mod(mod, n, io)
	99	ret \|= rsnd_dai_disconnect(mod);
	100
	101	return ret;
	102	}
	103
	104	static struct rsnd_gen_ops rsnd_gen1_ops = {
	105	.path_init = rsnd_gen1_path_init,
	106	.path_exit = rsnd_gen1_path_exit,
	107	};
	108
	109	#define RSND_GEN1_REG_MAP(g, s, i, oi, oa) \
	110	do { \
	111	(g)->reg_map[RSND_REG_##i].index = RSND_GEN1_##s; \
	112	(g)->reg_map[RSND_REG_##i].offset_id = oi; \
	113	(g)->reg_map[RSND_REG_##i].offset_adr = oa; \
	114	} while (0)
	115
	116	static void rsnd_gen1_reg_map_init(struct rsnd_gen *gen)
	117	{
	118	RSND_GEN1_REG_MAP(gen, SRU, SSI_MODE0, 0x0, 0xD0);
	119	RSND_GEN1_REG_MAP(gen, SRU, SSI_MODE1, 0x0, 0xD4);
dfc9403b KM	120
	121	RSND_GEN1_REG_MAP(gen, ADG, BRRA, 0x0, 0x00);
	122	RSND_GEN1_REG_MAP(gen, ADG, BRRB, 0x0, 0x04);
	123	RSND_GEN1_REG_MAP(gen, ADG, SSICKR, 0x0, 0x08);
	124	RSND_GEN1_REG_MAP(gen, ADG, AUDIO_CLK_SEL0, 0x0, 0x0c);
	125	RSND_GEN1_REG_MAP(gen, ADG, AUDIO_CLK_SEL1, 0x0, 0x10);
	126	RSND_GEN1_REG_MAP(gen, ADG, AUDIO_CLK_SEL3, 0x0, 0x18);
	127	RSND_GEN1_REG_MAP(gen, ADG, AUDIO_CLK_SEL4, 0x0, 0x1c);
	128	RSND_GEN1_REG_MAP(gen, ADG, AUDIO_CLK_SEL5, 0x0, 0x20);
ae5c3223 KM	129
	130	RSND_GEN1_REG_MAP(gen, SSI, SSICR, 0x40, 0x00);
	131	RSND_GEN1_REG_MAP(gen, SSI, SSISR, 0x40, 0x04);
	132	RSND_GEN1_REG_MAP(gen, SSI, SSITDR, 0x40, 0x08);
	133	RSND_GEN1_REG_MAP(gen, SSI, SSIRDR, 0x40, 0x0c);
	134	RSND_GEN1_REG_MAP(gen, SSI, SSIWSR, 0x40, 0x20);
07539c1d KM	135	}
07539c1d KM	136
3337744a KM	137	static int rsnd_gen1_probe(struct platform_device *pdev,
	138	struct rcar_snd_info *info,
	139	struct rsnd_priv *priv)
	140	{
07539c1d KM	141	struct device *dev = rsnd_priv_to_dev(priv);
	142	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
	143	struct resource *sru_res;
dfc9403b	144	struct resource *adg_res;
ae5c3223	145	struct resource *ssi_res;
07539c1d KM	146
	147	/*
	148	* map address
	149	*/
	150	sru_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_SRU);
dfc9403b	151	adg_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_ADG);
ae5c3223	152	ssi_res = platform_get_resource(pdev, IORESOURCE_MEM, RSND_GEN1_SSI);
dfc9403b	153	if (!sru_res \|\|
ae5c3223 KM	154	!adg_res \|\|
ae5c3223 KM	155	!ssi_res) {
07539c1d KM	156	dev_err(dev, "Not enough SRU/SSI/ADG platform resources.\n");
	157	return -ENODEV;
	158	}
	159
	160	gen->ops = &rsnd_gen1_ops;
	161
	162	gen->base[RSND_GEN1_SRU] = devm_ioremap_resource(dev, sru_res);
dfc9403b	163	gen->base[RSND_GEN1_ADG] = devm_ioremap_resource(dev, adg_res);
ae5c3223	164	gen->base[RSND_GEN1_SSI] = devm_ioremap_resource(dev, ssi_res);
dfc9403b	165	if (!gen->base[RSND_GEN1_SRU] \|\|
ae5c3223 KM	166	!gen->base[RSND_GEN1_ADG] \|\|
ae5c3223 KM	167	!gen->base[RSND_GEN1_SSI]) {
07539c1d KM	168	dev_err(dev, "SRU/SSI/ADG ioremap failed\n");
	169	return -ENODEV;
	170	}
	171
	172	rsnd_gen1_reg_map_init(gen);
	173
	174	dev_dbg(dev, "Gen1 device probed\n");
	175	dev_dbg(dev, "SRU : %08x => %p\n", sru_res->start,
	176	gen->base[RSND_GEN1_SRU]);
dfc9403b KM	177	dev_dbg(dev, "ADG : %08x => %p\n", adg_res->start,
dfc9403b KM	178	gen->base[RSND_GEN1_ADG]);
ae5c3223 KM	179	dev_dbg(dev, "SSI : %08x => %p\n", ssi_res->start,
ae5c3223 KM	180	gen->base[RSND_GEN1_SSI]);
07539c1d	181
3337744a	182	return 0;
ae5c3223	183
3337744a KM	184	}
	185
	186	static void rsnd_gen1_remove(struct platform_device *pdev,
	187	struct rsnd_priv *priv)
	188	{
	189	}
	190
	191	/*
	192	* Gen
	193	*/
	194	int rsnd_gen_path_init(struct rsnd_priv *priv,
	195	struct rsnd_dai *rdai,
	196	struct rsnd_dai_stream *io)
	197	{
	198	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
	199
	200	return gen->ops->path_init(priv, rdai, io);
	201	}
	202
	203	int rsnd_gen_path_exit(struct rsnd_priv *priv,
	204	struct rsnd_dai *rdai,
	205	struct rsnd_dai_stream *io)
	206	{
	207	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
	208
	209	return gen->ops->path_exit(priv, rdai, io);
	210	}
	211
	212	void __iomem rsnd_gen_reg_get(struct rsnd_priv priv,
	213	struct rsnd_mod *mod,
	214	enum rsnd_reg reg)
	215	{
	216	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
	217	struct device *dev = rsnd_priv_to_dev(priv);
	218	int index;
	219	u32 offset_id, offset_adr;
	220
	221	if (reg >= RSND_REG_MAX) {
	222	dev_err(dev, "rsnd_reg reg error\n");
	223	return NULL;
	224	}
	225
	226	index = gen->reg_map[reg].index;
	227	offset_id = gen->reg_map[reg].offset_id;
	228	offset_adr = gen->reg_map[reg].offset_adr;
	229
	230	if (index < 0) {
	231	dev_err(dev, "unsupported reg access %d\n", reg);
	232	return NULL;
	233	}
	234
	235	if (offset_id && mod)
	236	offset_id *= rsnd_mod_id(mod);
	237
	238	/*
	239	* index/offset were set on gen1/gen2
	240	*/
	241
	242	return gen->base[index] + offset_id + offset_adr;
	243	}
	244
	245	int rsnd_gen_probe(struct platform_device *pdev,
	246	struct rcar_snd_info *info,
	247	struct rsnd_priv *priv)
248	{
249	struct device *dev = rsnd_priv_to_dev(priv);
250	struct rsnd_gen *gen;
251	int i;
252
253	gen = devm_kzalloc(dev, sizeof(*gen), GFP_KERNEL);
254	if (!gen) {
255	dev_err(dev, "GEN allocate failed\n");
256	return -ENOMEM;
257	}
258
259	priv->gen = gen;
260
261	/*
262	* see
263	* rsnd_reg_get()
264	* rsnd_gen_probe()
265	*/
266	for (i = 0; i < RSND_REG_MAX; i++)
267	gen->reg_map[i].index = -1;
268
269	/*
270	* init each module
271	*/
272	if (rsnd_is_gen1(priv))
273	return rsnd_gen1_probe(pdev, info, priv);
274
275	dev_err(dev, "unknown generation R-Car sound device\n");
276
277	return -ENODEV;
278	}
279
280	void rsnd_gen_remove(struct platform_device *pdev,
281	struct rsnd_priv *priv)
282	{
283	if (rsnd_is_gen1(priv))
284	rsnd_gen1_remove(pdev, priv);
285	}