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

/*
 * #define DEBUG
 *
 * you can also add below in
 * ${LINUX}/drivers/base/regmap/regmap.c
 * for regmap debug
 *
 * #define LOG_DEVICE "xxxx.rcar_sound"
 */

#include "rsnd.h"

struct rsnd_gen {
	struct rsnd_gen_ops *ops;

	/* RSND_BASE_MAX base */
	void __iomem *base[RSND_BASE_MAX];
	phys_addr_t res[RSND_BASE_MAX];
	struct regmap *regmap[RSND_BASE_MAX];

	/* RSND_REG_MAX base */
	struct regmap_field *regs[RSND_REG_MAX];
};

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

struct rsnd_regmap_field_conf {
	int idx;
	unsigned int reg_offset;
	unsigned int id_offset;
};

#define RSND_REG_SET(id, offset, _id_offset)	\
{						\
	.idx = id,				\
	.reg_offset = offset,			\
	.id_offset = _id_offset,		\
}
/* single address mapping */
#define RSND_GEN_S_REG(id, offset)	\
	RSND_REG_SET(RSND_REG_##id, offset, 0)

/* multi address mapping */
#define RSND_GEN_M_REG(id, offset, _id_offset)	\
	RSND_REG_SET(RSND_REG_##id, offset, _id_offset)

/*
 *		basic function
 */
static int rsnd_is_accessible_reg(struct rsnd_priv *priv,
				  struct rsnd_gen *gen, enum rsnd_reg reg)
{
	if (!gen->regs[reg]) {
		struct device *dev = rsnd_priv_to_dev(priv);

		dev_err(dev, "unsupported register access %x\n", reg);
		return 0;
	}

	return 1;
}

u32 rsnd_read(struct rsnd_priv *priv,
	      struct rsnd_mod *mod, enum rsnd_reg reg)
{
	struct device *dev = rsnd_priv_to_dev(priv);
	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
	u32 val;

	if (!rsnd_is_accessible_reg(priv, gen, reg))
		return 0;

	regmap_fields_read(gen->regs[reg], rsnd_mod_id(mod), &val);

	dev_dbg(dev, "r %s[%d] - %4d : %08x\n",
		rsnd_mod_name(mod), rsnd_mod_id(mod), reg, val);

	return val;
}

void rsnd_write(struct rsnd_priv *priv,
		struct rsnd_mod *mod,
		enum rsnd_reg reg, u32 data)
{
	struct device *dev = rsnd_priv_to_dev(priv);
	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);

	if (!rsnd_is_accessible_reg(priv, gen, reg))
		return;

	dev_dbg(dev, "w %s[%d] - %4d : %08x\n",
		rsnd_mod_name(mod), rsnd_mod_id(mod), reg, data);

	regmap_fields_write(gen->regs[reg], rsnd_mod_id(mod), data);
}

void rsnd_force_write(struct rsnd_priv *priv,
		      struct rsnd_mod *mod,
		      enum rsnd_reg reg, u32 data)
{
	struct device *dev = rsnd_priv_to_dev(priv);
	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);

	if (!rsnd_is_accessible_reg(priv, gen, reg))
		return;

	dev_dbg(dev, "w %s[%d] - %4d : %08x\n",
		rsnd_mod_name(mod), rsnd_mod_id(mod), reg, data);

	regmap_fields_force_write(gen->regs[reg], rsnd_mod_id(mod), data);
}

void rsnd_bset(struct rsnd_priv *priv, struct rsnd_mod *mod,
	       enum rsnd_reg reg, u32 mask, u32 data)
{
	struct device *dev = rsnd_priv_to_dev(priv);
	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);

	if (!rsnd_is_accessible_reg(priv, gen, reg))
		return;

	dev_dbg(dev, "b %s[%d] - %4d : %08x/%08x\n",
		rsnd_mod_name(mod), rsnd_mod_id(mod), reg, data, mask);

	regmap_fields_update_bits(gen->regs[reg], rsnd_mod_id(mod),
				  mask, data);
}

phys_addr_t rsnd_gen_get_phy_addr(struct rsnd_priv *priv, int reg_id)
{
	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);

	return	gen->res[reg_id];
}

#define rsnd_gen_regmap_init(priv, id_size, reg_id, name, conf)		\
	_rsnd_gen_regmap_init(priv, id_size, reg_id, name, conf, ARRAY_SIZE(conf))
static int _rsnd_gen_regmap_init(struct rsnd_priv *priv,
				 int id_size,
				 int reg_id,
				 const char *name,
				 struct rsnd_regmap_field_conf *conf,
				 int conf_size)
{
	struct platform_device *pdev = rsnd_priv_to_pdev(priv);
	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
	struct device *dev = rsnd_priv_to_dev(priv);
	struct resource *res;
	struct regmap_config regc;
	struct regmap_field *regs;
	struct regmap *regmap;
	struct reg_field regf;
	void __iomem *base;
	int i;

	memset(&regc, 0, sizeof(regc));
	regc.reg_bits = 32;
	regc.val_bits = 32;
	regc.reg_stride = 4;
	regc.name = name;

	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
	if (!res)
		res = platform_get_resource(pdev, IORESOURCE_MEM, reg_id);
	if (!res)
		return -ENODEV;

	base = devm_ioremap_resource(dev, res);
	if (IS_ERR(base))
		return PTR_ERR(base);

	regmap = devm_regmap_init_mmio(dev, base, &regc);
	if (IS_ERR(regmap))
		return PTR_ERR(regmap);

	/* RSND_BASE_MAX base */
	gen->base[reg_id] = base;
	gen->regmap[reg_id] = regmap;
	gen->res[reg_id] = res->start;

	for (i = 0; i < conf_size; i++) {

		regf.reg	= conf[i].reg_offset;
		regf.id_offset	= conf[i].id_offset;
		regf.lsb	= 0;
		regf.msb	= 31;
		regf.id_size	= id_size;

		regs = devm_regmap_field_alloc(dev, regmap, regf);
		if (IS_ERR(regs))
			return PTR_ERR(regs);

		/* RSND_REG_MAX base */
		gen->regs[conf[i].idx] = regs;
	}

	return 0;
}

/*
 *		Gen2
 */
static int rsnd_gen2_probe(struct rsnd_priv *priv)
{
	struct rsnd_regmap_field_conf conf_ssiu[] = {
		RSND_GEN_S_REG(SSI_MODE0,	0x800),
		RSND_GEN_S_REG(SSI_MODE1,	0x804),
		/* FIXME: it needs SSI_MODE2/3 in the future */
		RSND_GEN_M_REG(SSI_BUSIF_MODE,	0x0,	0x80),
		RSND_GEN_M_REG(SSI_BUSIF_ADINR,	0x4,	0x80),
		RSND_GEN_M_REG(SSI_BUSIF_DALIGN,0x8,	0x80),
		RSND_GEN_M_REG(SSI_CTRL,	0x10,	0x80),
		RSND_GEN_M_REG(SSI_INT_ENABLE,	0x18,	0x80),
	};
	struct rsnd_regmap_field_conf conf_scu[] = {
		RSND_GEN_M_REG(SRC_BUSIF_MODE,	0x0,	0x20),
		RSND_GEN_M_REG(SRC_BUSIF_DALIGN,0x8,	0x20),
		RSND_GEN_M_REG(SRC_ROUTE_MODE0,	0xc,	0x20),
		RSND_GEN_M_REG(SRC_CTRL,	0x10,	0x20),
		RSND_GEN_M_REG(SRC_INT_ENABLE0,	0x18,	0x20),
		RSND_GEN_M_REG(CMD_ROUTE_SLCT,	0x18c,	0x20),
		RSND_GEN_M_REG(CMD_CTRL,	0x190,	0x20),
		RSND_GEN_S_REG(SCU_SYS_STATUS0,	0x1c8),
		RSND_GEN_S_REG(SCU_SYS_INT_EN0,	0x1cc),
		RSND_GEN_S_REG(SCU_SYS_STATUS1,	0x1d0),
		RSND_GEN_S_REG(SCU_SYS_INT_EN1,	0x1c4),
		RSND_GEN_M_REG(SRC_SWRSR,	0x200,	0x40),
		RSND_GEN_M_REG(SRC_SRCIR,	0x204,	0x40),
		RSND_GEN_M_REG(SRC_ADINR,	0x214,	0x40),
		RSND_GEN_M_REG(SRC_IFSCR,	0x21c,	0x40),
		RSND_GEN_M_REG(SRC_IFSVR,	0x220,	0x40),
		RSND_GEN_M_REG(SRC_SRCCR,	0x224,	0x40),
		RSND_GEN_M_REG(SRC_BSDSR,	0x22c,	0x40),
		RSND_GEN_M_REG(SRC_BSISR,	0x238,	0x40),
		RSND_GEN_M_REG(CTU_CTUIR,	0x504,	0x100),
		RSND_GEN_M_REG(CTU_ADINR,	0x508,	0x100),
		RSND_GEN_M_REG(MIX_SWRSR,	0xd00,	0x40),
		RSND_GEN_M_REG(MIX_MIXIR,	0xd04,	0x40),
		RSND_GEN_M_REG(MIX_ADINR,	0xd08,	0x40),
		RSND_GEN_M_REG(MIX_MIXMR,	0xd10,	0x40),
		RSND_GEN_M_REG(MIX_MVPDR,	0xd14,	0x40),
		RSND_GEN_M_REG(MIX_MDBAR,	0xd18,	0x40),
		RSND_GEN_M_REG(MIX_MDBBR,	0xd1c,	0x40),
		RSND_GEN_M_REG(MIX_MDBCR,	0xd20,	0x40),
		RSND_GEN_M_REG(MIX_MDBDR,	0xd24,	0x40),
		RSND_GEN_M_REG(MIX_MDBER,	0xd28,	0x40),
		RSND_GEN_M_REG(DVC_SWRSR,	0xe00,	0x100),
		RSND_GEN_M_REG(DVC_DVUIR,	0xe04,	0x100),
		RSND_GEN_M_REG(DVC_ADINR,	0xe08,	0x100),
		RSND_GEN_M_REG(DVC_DVUCR,	0xe10,	0x100),
		RSND_GEN_M_REG(DVC_ZCMCR,	0xe14,	0x100),
		RSND_GEN_M_REG(DVC_VRCTR,	0xe18,	0x100),
		RSND_GEN_M_REG(DVC_VRPDR,	0xe1c,	0x100),
		RSND_GEN_M_REG(DVC_VRDBR,	0xe20,	0x100),
		RSND_GEN_M_REG(DVC_VOL0R,	0xe28,	0x100),
		RSND_GEN_M_REG(DVC_VOL1R,	0xe2c,	0x100),
		RSND_GEN_M_REG(DVC_DVUER,	0xe48,	0x100),
	};
	struct rsnd_regmap_field_conf conf_adg[] = {
		RSND_GEN_S_REG(BRRA,		0x00),
		RSND_GEN_S_REG(BRRB,		0x04),
		RSND_GEN_S_REG(SSICKR,		0x08),
		RSND_GEN_S_REG(AUDIO_CLK_SEL0,	0x0c),
		RSND_GEN_S_REG(AUDIO_CLK_SEL1,	0x10),
		RSND_GEN_S_REG(AUDIO_CLK_SEL2,	0x14),
		RSND_GEN_S_REG(DIV_EN,		0x30),
		RSND_GEN_S_REG(SRCIN_TIMSEL0,	0x34),
		RSND_GEN_S_REG(SRCIN_TIMSEL1,	0x38),
		RSND_GEN_S_REG(SRCIN_TIMSEL2,	0x3c),
		RSND_GEN_S_REG(SRCIN_TIMSEL3,	0x40),
		RSND_GEN_S_REG(SRCIN_TIMSEL4,	0x44),
		RSND_GEN_S_REG(SRCOUT_TIMSEL0,	0x48),
		RSND_GEN_S_REG(SRCOUT_TIMSEL1,	0x4c),
		RSND_GEN_S_REG(SRCOUT_TIMSEL2,	0x50),
		RSND_GEN_S_REG(SRCOUT_TIMSEL3,	0x54),
		RSND_GEN_S_REG(SRCOUT_TIMSEL4,	0x58),
		RSND_GEN_S_REG(CMDOUT_TIMSEL,	0x5c),
	};
	struct rsnd_regmap_field_conf conf_ssi[] = {
		RSND_GEN_M_REG(SSICR,		0x00,	0x40),
		RSND_GEN_M_REG(SSISR,		0x04,	0x40),
		RSND_GEN_M_REG(SSITDR,		0x08,	0x40),
		RSND_GEN_M_REG(SSIRDR,		0x0c,	0x40),
		RSND_GEN_M_REG(SSIWSR,		0x20,	0x40),
	};
	int ret_ssiu;
	int ret_scu;
	int ret_adg;
	int ret_ssi;

	ret_ssiu = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SSIU, "ssiu", conf_ssiu);
	ret_scu  = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SCU,  "scu",  conf_scu);
	ret_adg  = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_ADG,  "adg",  conf_adg);
	ret_ssi  = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SSI,  "ssi",  conf_ssi);
	if (ret_ssiu < 0 ||
	    ret_scu  < 0 ||
	    ret_adg  < 0 ||
	    ret_ssi  < 0)
		return ret_ssiu | ret_scu | ret_adg | ret_ssi;

	return 0;
}

/*
 *		Gen1
 */

static int rsnd_gen1_probe(struct rsnd_priv *priv)
{
	struct rsnd_regmap_field_conf conf_adg[] = {
		RSND_GEN_S_REG(BRRA,		0x00),
		RSND_GEN_S_REG(BRRB,		0x04),
		RSND_GEN_S_REG(SSICKR,		0x08),
		RSND_GEN_S_REG(AUDIO_CLK_SEL0,	0x0c),
		RSND_GEN_S_REG(AUDIO_CLK_SEL1,	0x10),
	};
	struct rsnd_regmap_field_conf conf_ssi[] = {
		RSND_GEN_M_REG(SSICR,		0x00,	0x40),
		RSND_GEN_M_REG(SSISR,		0x04,	0x40),
		RSND_GEN_M_REG(SSITDR,		0x08,	0x40),
		RSND_GEN_M_REG(SSIRDR,		0x0c,	0x40),
		RSND_GEN_M_REG(SSIWSR,		0x20,	0x40),
	};
	int ret_adg;
	int ret_ssi;

	ret_adg  = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_ADG, "adg", conf_adg);
	ret_ssi  = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_SSI, "ssi", conf_ssi);
	if (ret_adg  < 0 ||
	    ret_ssi  < 0)
		return ret_adg | ret_ssi;

	return 0;
}

/*
 *		Gen
 */
int rsnd_gen_probe(struct rsnd_priv *priv)
{
	struct device *dev = rsnd_priv_to_dev(priv);
	struct rsnd_gen *gen;
	int ret;

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

	priv->gen = gen;

	ret = -ENODEV;
	if (rsnd_is_gen1(priv))
		ret = rsnd_gen1_probe(priv);
	else if (rsnd_is_gen2(priv))
		ret = rsnd_gen2_probe(priv);

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

	return ret;
}
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	*/
ace0eb1e KM	11
	12	/*
	13	* #define DEBUG
	14	*
	15	* you can also add below in
	16	* ${LINUX}/drivers/base/regmap/regmap.c
	17	* for regmap debug
	18	*
	19	* #define LOG_DEVICE "xxxx.rcar_sound"
	20	*/
	21
3337744a KM	22	#include "rsnd.h"
3337744a KM	23
3337744a	24	struct rsnd_gen {
3337744a	25	struct rsnd_gen_ops *ops;
55e5b6fd	26
9993c16d KM	27	/* RSND_BASE_MAX base */
	28	void __iomem *base[RSND_BASE_MAX];
	29	phys_addr_t res[RSND_BASE_MAX];
b8c63786	30	struct regmap *regmap[RSND_BASE_MAX];
9993c16d KM	31
9993c16d KM	32	/* RSND_REG_MAX base */
55e5b6fd	33	struct regmap_field *regs[RSND_REG_MAX];
3337744a KM	34	};
	35
	36	#define rsnd_priv_to_gen(p) ((struct rsnd_gen *)(p)->gen)
	37
b8c63786 KM	38	struct rsnd_regmap_field_conf {
	39	int idx;
	40	unsigned int reg_offset;
	41	unsigned int id_offset;
	42	};
55e5b6fd	43
b8c63786 KM	44	#define RSND_REG_SET(id, offset, _id_offset) \
	45	{ \
	46	.idx = id, \
	47	.reg_offset = offset, \
	48	.id_offset = _id_offset, \
55e5b6fd	49	}
b8c63786 KM	50	/* single address mapping */
	51	#define RSND_GEN_S_REG(id, offset) \
	52	RSND_REG_SET(RSND_REG_##id, offset, 0)
55e5b6fd	53
b8c63786 KM	54	/* multi address mapping */
	55	#define RSND_GEN_M_REG(id, offset, _id_offset) \
	56	RSND_REG_SET(RSND_REG_##id, offset, _id_offset)
55e5b6fd	57
b8c63786 KM	58	/*
	59	* basic function
	60	*/
42ee5d22 KM	61	static int rsnd_is_accessible_reg(struct rsnd_priv *priv,
	62	struct rsnd_gen *gen, enum rsnd_reg reg)
	63	{
	64	if (!gen->regs[reg]) {
	65	struct device *dev = rsnd_priv_to_dev(priv);
	66
	67	dev_err(dev, "unsupported register access %x\n", reg);
	68	return 0;
	69	}
	70
	71	return 1;
	72	}
	73
55e5b6fd KM	74	u32 rsnd_read(struct rsnd_priv *priv,
	75	struct rsnd_mod *mod, enum rsnd_reg reg)
	76	{
b8c63786	77	struct device *dev = rsnd_priv_to_dev(priv);
55e5b6fd KM	78	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
	79	u32 val;
	80
42ee5d22 KM	81	if (!rsnd_is_accessible_reg(priv, gen, reg))
	82	return 0;
	83
c9b9638f KM	84	regmap_fields_read(gen->regs[reg], rsnd_mod_id(mod), &val);
c9b9638f KM	85
30cc4faf	86	dev_dbg(dev, "r %s[%d] - %4d : %08x\n",
ace0eb1e	87	rsnd_mod_name(mod), rsnd_mod_id(mod), reg, val);
55e5b6fd KM	88
	89	return val;
	90	}
	91
	92	void rsnd_write(struct rsnd_priv *priv,
	93	struct rsnd_mod *mod,
	94	enum rsnd_reg reg, u32 data)
	95	{
b8c63786	96	struct device *dev = rsnd_priv_to_dev(priv);
55e5b6fd KM	97	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
55e5b6fd KM	98
42ee5d22 KM	99	if (!rsnd_is_accessible_reg(priv, gen, reg))
	100	return;
	101
30cc4faf	102	dev_dbg(dev, "w %s[%d] - %4d : %08x\n",
ace0eb1e	103	rsnd_mod_name(mod), rsnd_mod_id(mod), reg, data);
b8c63786	104
ace0eb1e	105	regmap_fields_write(gen->regs[reg], rsnd_mod_id(mod), data);
7b47ab47 KM	106	}
	107
	108	void rsnd_force_write(struct rsnd_priv *priv,
	109	struct rsnd_mod *mod,
	110	enum rsnd_reg reg, u32 data)
	111	{
	112	struct device *dev = rsnd_priv_to_dev(priv);
	113	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
	114
	115	if (!rsnd_is_accessible_reg(priv, gen, reg))
	116	return;
	117
	118	dev_dbg(dev, "w %s[%d] - %4d : %08x\n",
	119	rsnd_mod_name(mod), rsnd_mod_id(mod), reg, data);
	120
	121	regmap_fields_force_write(gen->regs[reg], rsnd_mod_id(mod), data);
55e5b6fd KM	122	}
	123
	124	void rsnd_bset(struct rsnd_priv priv, struct rsnd_mod mod,
	125	enum rsnd_reg reg, u32 mask, u32 data)
	126	{
4f8f86aa	127	struct device *dev = rsnd_priv_to_dev(priv);
55e5b6fd KM	128	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
55e5b6fd KM	129
42ee5d22 KM	130	if (!rsnd_is_accessible_reg(priv, gen, reg))
	131	return;
	132
30cc4faf	133	dev_dbg(dev, "b %s[%d] - %4d : %08x/%08x\n",
ace0eb1e KM	134	rsnd_mod_name(mod), rsnd_mod_id(mod), reg, data, mask);
ace0eb1e KM	135
55e5b6fd KM	136	regmap_fields_update_bits(gen->regs[reg], rsnd_mod_id(mod),
	137	mask, data);
	138	}
	139
c5212b45 KM	140	phys_addr_t rsnd_gen_get_phy_addr(struct rsnd_priv *priv, int reg_id)
	141	{
	142	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
	143
	144	return gen->res[reg_id];
	145	}
	146
7277911c KM	147	#define rsnd_gen_regmap_init(priv, id_size, reg_id, name, conf) \
7277911c KM	148	_rsnd_gen_regmap_init(priv, id_size, reg_id, name, conf, ARRAY_SIZE(conf))
b8c63786 KM	149	static int _rsnd_gen_regmap_init(struct rsnd_priv *priv,
	150	int id_size,
	151	int reg_id,
7277911c	152	const char *name,
b8c63786 KM	153	struct rsnd_regmap_field_conf *conf,
b8c63786 KM	154	int conf_size)
c1e6cc5e	155	{
b8c63786 KM	156	struct platform_device *pdev = rsnd_priv_to_pdev(priv);
b8c63786 KM	157	struct rsnd_gen *gen = rsnd_priv_to_gen(priv);
c1e6cc5e	158	struct device *dev = rsnd_priv_to_dev(priv);
b8c63786	159	struct resource *res;
c1e6cc5e	160	struct regmap_config regc;
b8c63786 KM	161	struct regmap_field *regs;
	162	struct regmap *regmap;
	163	struct reg_field regf;
	164	void __iomem *base;
	165	int i;
c1e6cc5e KM	166
	167	memset(&regc, 0, sizeof(regc));
	168	regc.reg_bits = 32;
	169	regc.val_bits = 32;
b8c63786	170	regc.reg_stride = 4;
530b7b4a	171	regc.name = name;
c1e6cc5e	172
7277911c KM	173	res = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
	174	if (!res)
	175	res = platform_get_resource(pdev, IORESOURCE_MEM, reg_id);
b8c63786 KM	176	if (!res)
	177	return -ENODEV;
	178
	179	base = devm_ioremap_resource(dev, res);
	180	if (IS_ERR(base))
	181	return PTR_ERR(base);
c1e6cc5e	182
b8c63786 KM	183	regmap = devm_regmap_init_mmio(dev, base, &regc);
	184	if (IS_ERR(regmap))
	185	return PTR_ERR(regmap);
42ee5d22	186
9993c16d	187	/* RSND_BASE_MAX base */
b8c63786 KM	188	gen->base[reg_id] = base;
b8c63786 KM	189	gen->regmap[reg_id] = regmap;
c5212b45	190	gen->res[reg_id] = res->start;
c1e6cc5e	191
b8c63786 KM	192	for (i = 0; i < conf_size; i++) {
	193
	194	regf.reg = conf[i].reg_offset;
	195	regf.id_offset = conf[i].id_offset;
	196	regf.lsb = 0;
	197	regf.msb = 31;
	198	regf.id_size = id_size;
	199
	200	regs = devm_regmap_field_alloc(dev, regmap, regf);
	201	if (IS_ERR(regs))
	202	return PTR_ERR(regs);
	203
9993c16d	204	/* RSND_REG_MAX base */
b8c63786	205	gen->regs[conf[i].idx] = regs;
c1e6cc5e KM	206	}
	207
	208	return 0;
	209	}
3337744a	210
994a9df1 KM	211	/*
994a9df1 KM	212	* Gen2
994a9df1	213	*/
2ea6b074	214	static int rsnd_gen2_probe(struct rsnd_priv *priv)
507d466c	215	{
b8c63786 KM	216	struct rsnd_regmap_field_conf conf_ssiu[] = {
	217	RSND_GEN_S_REG(SSI_MODE0, 0x800),
	218	RSND_GEN_S_REG(SSI_MODE1, 0x804),
	219	/* FIXME: it needs SSI_MODE2/3 in the future */
	220	RSND_GEN_M_REG(SSI_BUSIF_MODE, 0x0, 0x80),
	221	RSND_GEN_M_REG(SSI_BUSIF_ADINR, 0x4, 0x80),
cdde84d1	222	RSND_GEN_M_REG(SSI_BUSIF_DALIGN,0x8, 0x80),
b8c63786	223	RSND_GEN_M_REG(SSI_CTRL, 0x10, 0x80),
efa991dc	224	RSND_GEN_M_REG(SSI_INT_ENABLE, 0x18, 0x80),
b8c63786 KM	225	};
	226	struct rsnd_regmap_field_conf conf_scu[] = {
	227	RSND_GEN_M_REG(SRC_BUSIF_MODE, 0x0, 0x20),
4689032b	228	RSND_GEN_M_REG(SRC_BUSIF_DALIGN,0x8, 0x20),
b8c63786 KM	229	RSND_GEN_M_REG(SRC_ROUTE_MODE0, 0xc, 0x20),
b8c63786 KM	230	RSND_GEN_M_REG(SRC_CTRL, 0x10, 0x20),
cfcefe01	231	RSND_GEN_M_REG(SRC_INT_ENABLE0, 0x18, 0x20),
b8c63786 KM	232	RSND_GEN_M_REG(CMD_ROUTE_SLCT, 0x18c, 0x20),
b8c63786 KM	233	RSND_GEN_M_REG(CMD_CTRL, 0x190, 0x20),
cfcefe01 KM	234	RSND_GEN_S_REG(SCU_SYS_STATUS0, 0x1c8),
	235	RSND_GEN_S_REG(SCU_SYS_INT_EN0, 0x1cc),
	236	RSND_GEN_S_REG(SCU_SYS_STATUS1, 0x1d0),
	237	RSND_GEN_S_REG(SCU_SYS_INT_EN1, 0x1c4),
b8c63786 KM	238	RSND_GEN_M_REG(SRC_SWRSR, 0x200, 0x40),
	239	RSND_GEN_M_REG(SRC_SRCIR, 0x204, 0x40),
	240	RSND_GEN_M_REG(SRC_ADINR, 0x214, 0x40),
	241	RSND_GEN_M_REG(SRC_IFSCR, 0x21c, 0x40),
	242	RSND_GEN_M_REG(SRC_IFSVR, 0x220, 0x40),
	243	RSND_GEN_M_REG(SRC_SRCCR, 0x224, 0x40),
	244	RSND_GEN_M_REG(SRC_BSDSR, 0x22c, 0x40),
	245	RSND_GEN_M_REG(SRC_BSISR, 0x238, 0x40),
9269e3c3 KM	246	RSND_GEN_M_REG(CTU_CTUIR, 0x504, 0x100),
9269e3c3 KM	247	RSND_GEN_M_REG(CTU_ADINR, 0x508, 0x100),
70fb1052 KM	248	RSND_GEN_M_REG(MIX_SWRSR, 0xd00, 0x40),
	249	RSND_GEN_M_REG(MIX_MIXIR, 0xd04, 0x40),
	250	RSND_GEN_M_REG(MIX_ADINR, 0xd08, 0x40),
	251	RSND_GEN_M_REG(MIX_MIXMR, 0xd10, 0x40),
	252	RSND_GEN_M_REG(MIX_MVPDR, 0xd14, 0x40),
	253	RSND_GEN_M_REG(MIX_MDBAR, 0xd18, 0x40),
	254	RSND_GEN_M_REG(MIX_MDBBR, 0xd1c, 0x40),
	255	RSND_GEN_M_REG(MIX_MDBCR, 0xd20, 0x40),
	256	RSND_GEN_M_REG(MIX_MDBDR, 0xd24, 0x40),
	257	RSND_GEN_M_REG(MIX_MDBER, 0xd28, 0x40),
b8c63786 KM	258	RSND_GEN_M_REG(DVC_SWRSR, 0xe00, 0x100),
	259	RSND_GEN_M_REG(DVC_DVUIR, 0xe04, 0x100),
	260	RSND_GEN_M_REG(DVC_ADINR, 0xe08, 0x100),
	261	RSND_GEN_M_REG(DVC_DVUCR, 0xe10, 0x100),
	262	RSND_GEN_M_REG(DVC_ZCMCR, 0xe14, 0x100),
3539cacf KM	263	RSND_GEN_M_REG(DVC_VRCTR, 0xe18, 0x100),
	264	RSND_GEN_M_REG(DVC_VRPDR, 0xe1c, 0x100),
	265	RSND_GEN_M_REG(DVC_VRDBR, 0xe20, 0x100),
b8c63786 KM	266	RSND_GEN_M_REG(DVC_VOL0R, 0xe28, 0x100),
	267	RSND_GEN_M_REG(DVC_VOL1R, 0xe2c, 0x100),
	268	RSND_GEN_M_REG(DVC_DVUER, 0xe48, 0x100),
	269	};
	270	struct rsnd_regmap_field_conf conf_adg[] = {
	271	RSND_GEN_S_REG(BRRA, 0x00),
	272	RSND_GEN_S_REG(BRRB, 0x04),
	273	RSND_GEN_S_REG(SSICKR, 0x08),
	274	RSND_GEN_S_REG(AUDIO_CLK_SEL0, 0x0c),
	275	RSND_GEN_S_REG(AUDIO_CLK_SEL1, 0x10),
	276	RSND_GEN_S_REG(AUDIO_CLK_SEL2, 0x14),
	277	RSND_GEN_S_REG(DIV_EN, 0x30),
	278	RSND_GEN_S_REG(SRCIN_TIMSEL0, 0x34),
	279	RSND_GEN_S_REG(SRCIN_TIMSEL1, 0x38),
	280	RSND_GEN_S_REG(SRCIN_TIMSEL2, 0x3c),
	281	RSND_GEN_S_REG(SRCIN_TIMSEL3, 0x40),
	282	RSND_GEN_S_REG(SRCIN_TIMSEL4, 0x44),
	283	RSND_GEN_S_REG(SRCOUT_TIMSEL0, 0x48),
	284	RSND_GEN_S_REG(SRCOUT_TIMSEL1, 0x4c),
	285	RSND_GEN_S_REG(SRCOUT_TIMSEL2, 0x50),
	286	RSND_GEN_S_REG(SRCOUT_TIMSEL3, 0x54),
	287	RSND_GEN_S_REG(SRCOUT_TIMSEL4, 0x58),
	288	RSND_GEN_S_REG(CMDOUT_TIMSEL, 0x5c),
	289	};
	290	struct rsnd_regmap_field_conf conf_ssi[] = {
	291	RSND_GEN_M_REG(SSICR, 0x00, 0x40),
	292	RSND_GEN_M_REG(SSISR, 0x04, 0x40),
	293	RSND_GEN_M_REG(SSITDR, 0x08, 0x40),
	294	RSND_GEN_M_REG(SSIRDR, 0x0c, 0x40),
	295	RSND_GEN_M_REG(SSIWSR, 0x20, 0x40),
	296	};
	297	int ret_ssiu;
	298	int ret_scu;
	299	int ret_adg;
	300	int ret_ssi;
	301
7277911c KM	302	ret_ssiu = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SSIU, "ssiu", conf_ssiu);
	303	ret_scu = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SCU, "scu", conf_scu);
	304	ret_adg = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_ADG, "adg", conf_adg);
	305	ret_ssi = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SSI, "ssi", conf_ssi);
b8c63786 KM	306	if (ret_ssiu < 0 \|\|
	307	ret_scu < 0 \|\|
	308	ret_adg < 0 \|\|
	309	ret_ssi < 0)
	310	return ret_ssiu \| ret_scu \| ret_adg \| ret_ssi;
	311
507d466c KM	312	return 0;
	313	}
	314
994a9df1 KM	315	/*
	316	* Gen1
	317	*/
	318
2ea6b074	319	static int rsnd_gen1_probe(struct rsnd_priv *priv)
3337744a	320	{
b8c63786 KM	321	struct rsnd_regmap_field_conf conf_adg[] = {
	322	RSND_GEN_S_REG(BRRA, 0x00),
	323	RSND_GEN_S_REG(BRRB, 0x04),
	324	RSND_GEN_S_REG(SSICKR, 0x08),
	325	RSND_GEN_S_REG(AUDIO_CLK_SEL0, 0x0c),
	326	RSND_GEN_S_REG(AUDIO_CLK_SEL1, 0x10),
b8c63786 KM	327	};
	328	struct rsnd_regmap_field_conf conf_ssi[] = {
	329	RSND_GEN_M_REG(SSICR, 0x00, 0x40),
	330	RSND_GEN_M_REG(SSISR, 0x04, 0x40),
	331	RSND_GEN_M_REG(SSITDR, 0x08, 0x40),
	332	RSND_GEN_M_REG(SSIRDR, 0x0c, 0x40),
	333	RSND_GEN_M_REG(SSIWSR, 0x20, 0x40),
	334	};
b8c63786 KM	335	int ret_adg;
b8c63786 KM	336	int ret_ssi;
07539c1d	337
7277911c KM	338	ret_adg = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_ADG, "adg", conf_adg);
7277911c KM	339	ret_ssi = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_SSI, "ssi", conf_ssi);
e8e7b7bd	340	if (ret_adg < 0 \|\|
b8c63786	341	ret_ssi < 0)
e8e7b7bd	342	return ret_adg \| ret_ssi;
07539c1d	343
3337744a KM	344	return 0;
	345	}
	346
3337744a KM	347	/*
	348	* Gen
	349	*/
2ea6b074	350	int rsnd_gen_probe(struct rsnd_priv *priv)
3337744a KM	351	{
	352	struct device *dev = rsnd_priv_to_dev(priv);
	353	struct rsnd_gen *gen;
531eaf49	354	int ret;
3337744a KM	355
	356	gen = devm_kzalloc(dev, sizeof(*gen), GFP_KERNEL);
	357	if (!gen) {
	358	dev_err(dev, "GEN allocate failed\n");
	359	return -ENOMEM;
	360	}
	361
531eaf49	362	priv->gen = gen;
072188b6	363
507d466c KM	364	ret = -ENODEV;
507d466c KM	365	if (rsnd_is_gen1(priv))
2ea6b074	366	ret = rsnd_gen1_probe(priv);
507d466c	367	else if (rsnd_is_gen2(priv))
2ea6b074	368	ret = rsnd_gen2_probe(priv);
507d466c KM	369
507d466c KM	370	if (ret < 0)
072188b6	371	dev_err(dev, "unknown generation R-Car sound device\n");
072188b6	372
531eaf49	373	return ret;
3337744a	374	}