[mirror_ubuntu-zesty-kernel.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 platform_device *pdev,
			   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,	0x1d4),
		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 platform_device *pdev,
			   struct rsnd_priv *priv)
{
	struct rsnd_regmap_field_conf conf_sru[] = {
		RSND_GEN_S_REG(SRC_ROUTE_SEL,	0x00),
		RSND_GEN_S_REG(SRC_TMG_SEL0,	0x08),
		RSND_GEN_S_REG(SRC_TMG_SEL1,	0x0c),
		RSND_GEN_S_REG(SRC_TMG_SEL2,	0x10),
		RSND_GEN_S_REG(SRC_ROUTE_CTRL,	0xc0),
		RSND_GEN_S_REG(SSI_MODE0,	0xD0),
		RSND_GEN_S_REG(SSI_MODE1,	0xD4),
		RSND_GEN_M_REG(SRC_BUSIF_MODE,	0x20,	0x4),
		RSND_GEN_M_REG(SRC_ROUTE_MODE0,	0x50,	0x8),
		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_MNFSR,	0x228,	0x40),
		/*
		 * ADD US
		 *
		 * SRC_STATUS
		 * SRC_INT_EN
		 * SCU_SYS_STATUS0
		 * SCU_SYS_STATUS1
		 * SCU_SYS_INT_EN0
		 * SCU_SYS_INT_EN1
		 */
	};
	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_SEL3,	0x18),
		RSND_GEN_S_REG(AUDIO_CLK_SEL4,	0x1c),
		RSND_GEN_S_REG(AUDIO_CLK_SEL5,	0x20),
	};
	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_sru;
	int ret_adg;
	int ret_ssi;

	ret_sru  = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_SRU, "sru", conf_sru);
	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_sru  < 0 ||
	    ret_adg  < 0 ||
	    ret_ssi  < 0)
		return ret_sru | ret_adg | ret_ssi;

	return 0;
}

/*
 *		Gen
 */
static void rsnd_of_parse_gen(struct platform_device *pdev,
			      const struct rsnd_of_data *of_data,
			      struct rsnd_priv *priv)
{
	struct rcar_snd_info *info = priv->info;

	if (!of_data)
		return;

	info->flags = of_data->flags;
}

int rsnd_gen_probe(struct platform_device *pdev,
		   const struct rsnd_of_data *of_data,
		   struct rsnd_priv *priv)
{
	struct device *dev = rsnd_priv_to_dev(priv);
	struct rsnd_gen *gen;
	int ret;

	rsnd_of_parse_gen(pdev, of_data, priv);

	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(pdev, priv);
	else if (rsnd_is_gen2(priv))
		ret = rsnd_gen2_probe(pdev, 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	*/
507d466c	214	static int rsnd_gen2_probe(struct platform_device *pdev,
507d466c KM	215	struct rsnd_priv *priv)
507d466c KM	216	{
b8c63786 KM	217	struct rsnd_regmap_field_conf conf_ssiu[] = {
	218	RSND_GEN_S_REG(SSI_MODE0, 0x800),
	219	RSND_GEN_S_REG(SSI_MODE1, 0x804),
	220	/* FIXME: it needs SSI_MODE2/3 in the future */
	221	RSND_GEN_M_REG(SSI_BUSIF_MODE, 0x0, 0x80),
	222	RSND_GEN_M_REG(SSI_BUSIF_ADINR, 0x4, 0x80),
cdde84d1	223	RSND_GEN_M_REG(SSI_BUSIF_DALIGN,0x8, 0x80),
b8c63786	224	RSND_GEN_M_REG(SSI_CTRL, 0x10, 0x80),
efa991dc	225	RSND_GEN_M_REG(SSI_INT_ENABLE, 0x18, 0x80),
b8c63786 KM	226	};
	227	struct rsnd_regmap_field_conf conf_scu[] = {
	228	RSND_GEN_M_REG(SRC_BUSIF_MODE, 0x0, 0x20),
4689032b	229	RSND_GEN_M_REG(SRC_BUSIF_DALIGN,0x8, 0x20),
b8c63786 KM	230	RSND_GEN_M_REG(SRC_ROUTE_MODE0, 0xc, 0x20),
b8c63786 KM	231	RSND_GEN_M_REG(SRC_CTRL, 0x10, 0x20),
cfcefe01	232	RSND_GEN_M_REG(SRC_INT_ENABLE0, 0x18, 0x20),
b8c63786 KM	233	RSND_GEN_M_REG(CMD_ROUTE_SLCT, 0x18c, 0x20),
b8c63786 KM	234	RSND_GEN_M_REG(CMD_CTRL, 0x190, 0x20),
cfcefe01 KM	235	RSND_GEN_S_REG(SCU_SYS_STATUS0, 0x1c8),
	236	RSND_GEN_S_REG(SCU_SYS_INT_EN0, 0x1cc),
	237	RSND_GEN_S_REG(SCU_SYS_STATUS1, 0x1d0),
021c5d94	238	RSND_GEN_S_REG(SCU_SYS_INT_EN1, 0x1d4),
b8c63786 KM	239	RSND_GEN_M_REG(SRC_SWRSR, 0x200, 0x40),
	240	RSND_GEN_M_REG(SRC_SRCIR, 0x204, 0x40),
	241	RSND_GEN_M_REG(SRC_ADINR, 0x214, 0x40),
	242	RSND_GEN_M_REG(SRC_IFSCR, 0x21c, 0x40),
	243	RSND_GEN_M_REG(SRC_IFSVR, 0x220, 0x40),
	244	RSND_GEN_M_REG(SRC_SRCCR, 0x224, 0x40),
	245	RSND_GEN_M_REG(SRC_BSDSR, 0x22c, 0x40),
	246	RSND_GEN_M_REG(SRC_BSISR, 0x238, 0x40),
9269e3c3 KM	247	RSND_GEN_M_REG(CTU_CTUIR, 0x504, 0x100),
9269e3c3 KM	248	RSND_GEN_M_REG(CTU_ADINR, 0x508, 0x100),
70fb1052 KM	249	RSND_GEN_M_REG(MIX_SWRSR, 0xd00, 0x40),
	250	RSND_GEN_M_REG(MIX_MIXIR, 0xd04, 0x40),
	251	RSND_GEN_M_REG(MIX_ADINR, 0xd08, 0x40),
	252	RSND_GEN_M_REG(MIX_MIXMR, 0xd10, 0x40),
	253	RSND_GEN_M_REG(MIX_MVPDR, 0xd14, 0x40),
	254	RSND_GEN_M_REG(MIX_MDBAR, 0xd18, 0x40),
	255	RSND_GEN_M_REG(MIX_MDBBR, 0xd1c, 0x40),
	256	RSND_GEN_M_REG(MIX_MDBCR, 0xd20, 0x40),
	257	RSND_GEN_M_REG(MIX_MDBDR, 0xd24, 0x40),
	258	RSND_GEN_M_REG(MIX_MDBER, 0xd28, 0x40),
b8c63786 KM	259	RSND_GEN_M_REG(DVC_SWRSR, 0xe00, 0x100),
	260	RSND_GEN_M_REG(DVC_DVUIR, 0xe04, 0x100),
	261	RSND_GEN_M_REG(DVC_ADINR, 0xe08, 0x100),
	262	RSND_GEN_M_REG(DVC_DVUCR, 0xe10, 0x100),
	263	RSND_GEN_M_REG(DVC_ZCMCR, 0xe14, 0x100),
3539cacf KM	264	RSND_GEN_M_REG(DVC_VRCTR, 0xe18, 0x100),
	265	RSND_GEN_M_REG(DVC_VRPDR, 0xe1c, 0x100),
	266	RSND_GEN_M_REG(DVC_VRDBR, 0xe20, 0x100),
b8c63786 KM	267	RSND_GEN_M_REG(DVC_VOL0R, 0xe28, 0x100),
	268	RSND_GEN_M_REG(DVC_VOL1R, 0xe2c, 0x100),
	269	RSND_GEN_M_REG(DVC_DVUER, 0xe48, 0x100),
	270	};
	271	struct rsnd_regmap_field_conf conf_adg[] = {
	272	RSND_GEN_S_REG(BRRA, 0x00),
	273	RSND_GEN_S_REG(BRRB, 0x04),
	274	RSND_GEN_S_REG(SSICKR, 0x08),
	275	RSND_GEN_S_REG(AUDIO_CLK_SEL0, 0x0c),
	276	RSND_GEN_S_REG(AUDIO_CLK_SEL1, 0x10),
	277	RSND_GEN_S_REG(AUDIO_CLK_SEL2, 0x14),
	278	RSND_GEN_S_REG(DIV_EN, 0x30),
	279	RSND_GEN_S_REG(SRCIN_TIMSEL0, 0x34),
	280	RSND_GEN_S_REG(SRCIN_TIMSEL1, 0x38),
	281	RSND_GEN_S_REG(SRCIN_TIMSEL2, 0x3c),
	282	RSND_GEN_S_REG(SRCIN_TIMSEL3, 0x40),
	283	RSND_GEN_S_REG(SRCIN_TIMSEL4, 0x44),
	284	RSND_GEN_S_REG(SRCOUT_TIMSEL0, 0x48),
	285	RSND_GEN_S_REG(SRCOUT_TIMSEL1, 0x4c),
	286	RSND_GEN_S_REG(SRCOUT_TIMSEL2, 0x50),
	287	RSND_GEN_S_REG(SRCOUT_TIMSEL3, 0x54),
	288	RSND_GEN_S_REG(SRCOUT_TIMSEL4, 0x58),
	289	RSND_GEN_S_REG(CMDOUT_TIMSEL, 0x5c),
	290	};
	291	struct rsnd_regmap_field_conf conf_ssi[] = {
	292	RSND_GEN_M_REG(SSICR, 0x00, 0x40),
	293	RSND_GEN_M_REG(SSISR, 0x04, 0x40),
	294	RSND_GEN_M_REG(SSITDR, 0x08, 0x40),
	295	RSND_GEN_M_REG(SSIRDR, 0x0c, 0x40),
	296	RSND_GEN_M_REG(SSIWSR, 0x20, 0x40),
	297	};
	298	int ret_ssiu;
	299	int ret_scu;
	300	int ret_adg;
	301	int ret_ssi;
	302
7277911c KM	303	ret_ssiu = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SSIU, "ssiu", conf_ssiu);
	304	ret_scu = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SCU, "scu", conf_scu);
	305	ret_adg = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_ADG, "adg", conf_adg);
	306	ret_ssi = rsnd_gen_regmap_init(priv, 10, RSND_GEN2_SSI, "ssi", conf_ssi);
b8c63786 KM	307	if (ret_ssiu < 0 \|\|
	308	ret_scu < 0 \|\|
	309	ret_adg < 0 \|\|
	310	ret_ssi < 0)
	311	return ret_ssiu \| ret_scu \| ret_adg \| ret_ssi;
	312
507d466c KM	313	return 0;
	314	}
	315
994a9df1 KM	316	/*
	317	* Gen1
	318	*/
	319
3337744a	320	static int rsnd_gen1_probe(struct platform_device *pdev,
3337744a KM	321	struct rsnd_priv *priv)
3337744a KM	322	{
b8c63786 KM	323	struct rsnd_regmap_field_conf conf_sru[] = {
	324	RSND_GEN_S_REG(SRC_ROUTE_SEL, 0x00),
	325	RSND_GEN_S_REG(SRC_TMG_SEL0, 0x08),
	326	RSND_GEN_S_REG(SRC_TMG_SEL1, 0x0c),
	327	RSND_GEN_S_REG(SRC_TMG_SEL2, 0x10),
	328	RSND_GEN_S_REG(SRC_ROUTE_CTRL, 0xc0),
	329	RSND_GEN_S_REG(SSI_MODE0, 0xD0),
	330	RSND_GEN_S_REG(SSI_MODE1, 0xD4),
	331	RSND_GEN_M_REG(SRC_BUSIF_MODE, 0x20, 0x4),
	332	RSND_GEN_M_REG(SRC_ROUTE_MODE0, 0x50, 0x8),
	333	RSND_GEN_M_REG(SRC_SWRSR, 0x200, 0x40),
	334	RSND_GEN_M_REG(SRC_SRCIR, 0x204, 0x40),
	335	RSND_GEN_M_REG(SRC_ADINR, 0x214, 0x40),
	336	RSND_GEN_M_REG(SRC_IFSCR, 0x21c, 0x40),
	337	RSND_GEN_M_REG(SRC_IFSVR, 0x220, 0x40),
	338	RSND_GEN_M_REG(SRC_SRCCR, 0x224, 0x40),
	339	RSND_GEN_M_REG(SRC_MNFSR, 0x228, 0x40),
cfcefe01 KM	340	/*
	341	* ADD US
	342	*
	343	* SRC_STATUS
	344	* SRC_INT_EN
	345	* SCU_SYS_STATUS0
	346	* SCU_SYS_STATUS1
	347	* SCU_SYS_INT_EN0
	348	* SCU_SYS_INT_EN1
	349	*/
b8c63786 KM	350	};
	351	struct rsnd_regmap_field_conf conf_adg[] = {
	352	RSND_GEN_S_REG(BRRA, 0x00),
	353	RSND_GEN_S_REG(BRRB, 0x04),
	354	RSND_GEN_S_REG(SSICKR, 0x08),
	355	RSND_GEN_S_REG(AUDIO_CLK_SEL0, 0x0c),
	356	RSND_GEN_S_REG(AUDIO_CLK_SEL1, 0x10),
	357	RSND_GEN_S_REG(AUDIO_CLK_SEL3, 0x18),
	358	RSND_GEN_S_REG(AUDIO_CLK_SEL4, 0x1c),
	359	RSND_GEN_S_REG(AUDIO_CLK_SEL5, 0x20),
	360	};
	361	struct rsnd_regmap_field_conf conf_ssi[] = {
	362	RSND_GEN_M_REG(SSICR, 0x00, 0x40),
	363	RSND_GEN_M_REG(SSISR, 0x04, 0x40),
	364	RSND_GEN_M_REG(SSITDR, 0x08, 0x40),
	365	RSND_GEN_M_REG(SSIRDR, 0x0c, 0x40),
	366	RSND_GEN_M_REG(SSIWSR, 0x20, 0x40),
	367	};
	368	int ret_sru;
	369	int ret_adg;
	370	int ret_ssi;
07539c1d	371
7277911c KM	372	ret_sru = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_SRU, "sru", conf_sru);
	373	ret_adg = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_ADG, "adg", conf_adg);
	374	ret_ssi = rsnd_gen_regmap_init(priv, 9, RSND_GEN1_SSI, "ssi", conf_ssi);
b8c63786 KM	375	if (ret_sru < 0 \|\|
	376	ret_adg < 0 \|\|
	377	ret_ssi < 0)
	378	return ret_sru \| ret_adg \| ret_ssi;
07539c1d	379
3337744a KM	380	return 0;
	381	}
	382
3337744a KM	383	/*
	384	* Gen
	385	*/
90e8e50f KM	386	static void rsnd_of_parse_gen(struct platform_device *pdev,
	387	const struct rsnd_of_data *of_data,
	388	struct rsnd_priv *priv)
	389	{
	390	struct rcar_snd_info *info = priv->info;
	391
	392	if (!of_data)
	393	return;
	394
	395	info->flags = of_data->flags;
	396	}
	397
3337744a	398	int rsnd_gen_probe(struct platform_device *pdev,
90e8e50f	399	const struct rsnd_of_data *of_data,
3337744a KM	400	struct rsnd_priv *priv)
	401	{
	402	struct device *dev = rsnd_priv_to_dev(priv);
	403	struct rsnd_gen *gen;
531eaf49	404	int ret;
3337744a	405
90e8e50f KM	406	rsnd_of_parse_gen(pdev, of_data, priv);
90e8e50f KM	407
3337744a KM	408	gen = devm_kzalloc(dev, sizeof(*gen), GFP_KERNEL);
	409	if (!gen) {
	410	dev_err(dev, "GEN allocate failed\n");
	411	return -ENOMEM;
	412	}
	413
531eaf49	414	priv->gen = gen;
072188b6	415
507d466c KM	416	ret = -ENODEV;
507d466c KM	417	if (rsnd_is_gen1(priv))
5da39cf3	418	ret = rsnd_gen1_probe(pdev, priv);
507d466c	419	else if (rsnd_is_gen2(priv))
5da39cf3	420	ret = rsnd_gen2_probe(pdev, priv);
507d466c KM	421
507d466c KM	422	if (ret < 0)
072188b6	423	dev_err(dev, "unknown generation R-Car sound device\n");
072188b6	424
531eaf49	425	return ret;
3337744a	426	}