自学教程：C++ rsnd_mod_id函数代码示例

static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io,			     struct rsnd_mod *mod){	struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);	struct rsnd_mod *src = rsnd_io_to_mod_src(io);	struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);	const u8 *entry = NULL;	int id = rsnd_mod_id(mod);	int size = 0;	if (mod == ssi) {		entry = gen2_id_table_ssiu;		size = ARRAY_SIZE(gen2_id_table_ssiu);	} else if (mod == src) {		entry = gen2_id_table_scu;		size = ARRAY_SIZE(gen2_id_table_scu);	} else if (mod == dvc) {		entry = gen2_id_table_cmd;		size = ARRAY_SIZE(gen2_id_table_cmd);	}	if ((!entry) || (size <= id)) {		struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io));		dev_err(dev, "unknown connection (%s[%d])/n",			rsnd_mod_name(mod), rsnd_mod_id(mod));		/* use non-prohibited SRS number as error */		return 0x00; /* SSI00 */	}	return entry[id];}

char *rsnd_mod_name(struct rsnd_mod *mod){	static char names[MOD_NAME_NUM][MOD_NAME_SIZE];	static int num;	char *name = names[num];	num++;	if (num >= MOD_NAME_NUM)		num = 0;	/*	 * Let's use same char to avoid pointlessness memory	 * Thus, rsnd_mod_name() should be used immediately	 * Don't keep pointer	 */	if ((mod)->ops->id_sub) {		snprintf(name, MOD_NAME_SIZE, "%s[%d%d]",			 mod->ops->name,			 rsnd_mod_id(mod),			 rsnd_mod_id_sub(mod));	} else {		snprintf(name, MOD_NAME_SIZE, "%s[%d]",			 mod->ops->name,			 rsnd_mod_id(mod));	}	return name;}

static u32 rsnd_ssi_run_mods(struct rsnd_dai_stream *io){	struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io);	struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io);	return rsnd_ssi_multi_slaves_runtime(io) |		1 << rsnd_mod_id(ssi_mod) |		1 << rsnd_mod_id(ssi_parent_mod);}

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

static void rsnd_adg_set_ssi_clk(struct rsnd_mod *ssi_mod, u32 val){	struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);	struct rsnd_adg *adg = rsnd_priv_to_adg(priv);	struct rsnd_mod *adg_mod = rsnd_mod_get(adg);	int id = rsnd_mod_id(ssi_mod);	int shift = (id % 4) * 8;	u32 mask = 0xFF << shift;	rsnd_mod_confirm_ssi(ssi_mod);	val = val << shift;	/*	 * SSI 8 is not connected to ADG.	 * it works with SSI 7	 */	if (id == 8)		return;	switch (id / 4) {	case 0:		rsnd_mod_bset(adg_mod, AUDIO_CLK_SEL0, mask, val);		break;	case 1:		rsnd_mod_bset(adg_mod, AUDIO_CLK_SEL1, mask, val);		break;	case 2:		rsnd_mod_bset(adg_mod, AUDIO_CLK_SEL2, mask, val);		break;	}}

/* *		SSI PIO */static void rsnd_ssi_parent_attach(struct rsnd_mod *mod,				   struct rsnd_dai_stream *io){	struct rsnd_dai *rdai = rsnd_io_to_rdai(io);	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	if (!__rsnd_ssi_is_pin_sharing(mod))		return;	if (!rsnd_rdai_is_clk_master(rdai))		return;	switch (rsnd_mod_id(mod)) {	case 1:	case 2:		rsnd_dai_connect(rsnd_ssi_mod_get(priv, 0), io, RSND_MOD_SSIP);		break;	case 4:		rsnd_dai_connect(rsnd_ssi_mod_get(priv, 3), io, RSND_MOD_SSIP);		break;	case 8:		rsnd_dai_connect(rsnd_ssi_mod_get(priv, 7), io, RSND_MOD_SSIP);		break;	}}

static int rsnd_ssi_quit(struct rsnd_mod *mod,			 struct rsnd_dai_stream *io,			 struct rsnd_priv *priv){	struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);	struct device *dev = rsnd_priv_to_dev(priv);	if (!rsnd_ssi_is_run_mods(mod, io))		return 0;	if (!ssi->usrcnt) {		dev_err(dev, "%s[%d] usrcnt error/n",			rsnd_mod_name(mod), rsnd_mod_id(mod));		return -EIO;	}	if (!rsnd_ssi_is_parent(mod, io))		ssi->cr_own	= 0;	rsnd_ssi_master_clk_stop(mod, io);	rsnd_mod_power_off(mod);	ssi->usrcnt--;	return 0;}

static void rsnd_ssi_hw_start(struct rsnd_ssi *ssi,			      struct rsnd_dai *rdai,			      struct rsnd_dai_stream *io){	struct rsnd_priv *priv = rsnd_mod_to_priv(&ssi->mod);	struct device *dev = rsnd_priv_to_dev(priv);	u32 cr;	if (0 == ssi->usrcnt) {		clk_enable(ssi->clk);		if (rsnd_rdai_is_clk_master(rdai)) {			if (rsnd_ssi_clk_from_parent(ssi))				rsnd_ssi_hw_start(ssi->parent, rdai, io);			else				rsnd_ssi_master_clk_start(ssi, io);		}	}	cr  =	ssi->cr_own	|		ssi->cr_clk	|		ssi->cr_etc	|		EN;	rsnd_mod_write(&ssi->mod, SSICR, cr);	ssi->usrcnt++;	dev_dbg(dev, "ssi%d hw started/n", rsnd_mod_id(&ssi->mod));}

static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io,			     struct rsnd_mod *mod){	struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io);	struct rsnd_mod *src = rsnd_io_to_mod_src(io);	struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io);	const u8 *entry = NULL;	int id = rsnd_mod_id(mod);	int size = 0;	if (mod == ssi) {		entry = gen2_id_table_ssiu;		size = ARRAY_SIZE(gen2_id_table_ssiu);	} else if (mod == src) {		entry = gen2_id_table_scu;		size = ARRAY_SIZE(gen2_id_table_scu);	} else if (mod == dvc) {		entry = gen2_id_table_cmd;		size = ARRAY_SIZE(gen2_id_table_cmd);	}	if (!entry)		return 0xFF;	if (size <= id)		return 0xFF;	return entry[id];}

static dma_addr_trsnd_gen2_dma_addr(struct rsnd_dai_stream *io,		   struct rsnd_mod *mod,		   int is_play, int is_from){	struct rsnd_priv *priv = rsnd_io_to_priv(io);	struct device *dev = rsnd_priv_to_dev(priv);	phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI);	phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU);	int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod);	int use_src = !!rsnd_io_to_mod_src(io);	int use_dvc = !!rsnd_io_to_mod_dvc(io);	int id = rsnd_mod_id(mod);	struct dma_addr {		dma_addr_t out_addr;		dma_addr_t in_addr;	} dma_addrs[3][2][3] = {		/* SRC */		{{{ 0,				0 },		  /* Capture */		  { RDMA_SRC_O_N(src, id),	RDMA_SRC_I_P(src, id) },		  { RDMA_CMD_O_N(src, id),	RDMA_SRC_I_P(src, id) } },		 /* Playback */		 {{ 0,				0, },		  { RDMA_SRC_O_P(src, id),	RDMA_SRC_I_N(src, id) },		  { RDMA_CMD_O_P(src, id),	RDMA_SRC_I_N(src, id) } }		},		/* SSI */		/* Capture */		{{{ RDMA_SSI_O_N(ssi, id),	0 },		  { RDMA_SSIU_O_P(ssi, id),	0 },		  { RDMA_SSIU_O_P(ssi, id),	0 } },		 /* Playback */		 {{ 0,				RDMA_SSI_I_N(ssi, id) },		  { 0,				RDMA_SSIU_I_P(ssi, id) },		  { 0,				RDMA_SSIU_I_P(ssi, id) } }		},		/* SSIU */		/* Capture */		{{{ RDMA_SSIU_O_N(ssi, id),	0 },		  { RDMA_SSIU_O_P(ssi, id),	0 },		  { RDMA_SSIU_O_P(ssi, id),	0 } },		 /* Playback */		 {{ 0,				RDMA_SSIU_I_N(ssi, id) },		  { 0,				RDMA_SSIU_I_P(ssi, id) },		  { 0,				RDMA_SSIU_I_P(ssi, id) } } },	};	/* it shouldn't happen */	if (use_dvc && !use_src)		dev_err(dev, "DVC is selected without SRC/n");	/* use SSIU or SSI ? */	if (is_ssi && rsnd_ssi_use_busif(io, mod))		is_ssi++;	return (is_from) ?		dma_addrs[is_ssi][is_play][use_src + use_dvc].out_addr :		dma_addrs[is_ssi][is_play][use_src + use_dvc].in_addr;}

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

static void rsnd_src_error_clear_gen2(struct rsnd_mod *mod){	u32 val = OUF_SRC(rsnd_mod_id(mod));	rsnd_mod_bset(mod, SCU_SYS_STATUS0, val, val);	rsnd_mod_bset(mod, SCU_SYS_STATUS1, val, val);}

static int rsnd_src_probe_gen2(struct rsnd_mod *mod,			       struct rsnd_dai *rdai,			       struct rsnd_dai_stream *io){	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct rcar_snd_info *info = rsnd_priv_to_info(priv);	struct rsnd_src *src = rsnd_mod_to_src(mod);	struct rsnd_mod *ssi = rsnd_ssi_mod_get(priv, rsnd_mod_id(mod));	struct device *dev = rsnd_priv_to_dev(priv);	int ret;	int is_play;	if (info->dai_info)		is_play = rsnd_info_is_playback(priv, src);	else		is_play = rsnd_ssi_is_play(ssi);	ret = rsnd_dma_init(priv,			    rsnd_mod_to_dma(mod),			    is_play,			    src->info->dma_id);	if (ret < 0)		dev_err(dev, "SRC DMA failed/n");	return ret;}

static void rsnd_src_irq_ctrol_gen2(struct rsnd_mod *mod, int enable){	struct rsnd_src *src = rsnd_mod_to_src(mod);	u32 sys_int_val, int_val, sys_int_mask;	int irq = src->info->irq;	int id = rsnd_mod_id(mod);	sys_int_val =	sys_int_mask = OUF_SRC(id);	int_val = 0x3300;	/*	 * IRQ is not supported on non-DT	 * see	 *	rsnd_src_probe_gen2()	 */	if ((irq <= 0) || !enable) {		sys_int_val = 0;		int_val = 0;	}	rsnd_mod_write(mod, SRC_INT_ENABLE0, int_val);	rsnd_mod_bset(mod, SCU_SYS_INT_EN0, sys_int_mask, sys_int_val);	rsnd_mod_bset(mod, SCU_SYS_INT_EN1, sys_int_mask, sys_int_val);}

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_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;	regmap_fields_update_bits(gen->regs[reg], rsnd_mod_id(mod),				  mask, data);	dev_dbg(dev, "b %s[%d] - %-18s (%4d) : %08x/%08x/n",		rsnd_mod_name(mod), rsnd_mod_id(mod),		rsnd_reg_name(gen, reg), reg, data, mask);}

static int rsnd_src_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_src *src = rsnd_mod_to_src(mod);	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);	u32 convert_rate = rsnd_src_convert_rate(src);	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;}

int rsnd_adg_ssi_clk_try_start(struct rsnd_mod *mod, unsigned int rate){	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct rsnd_adg *adg = rsnd_priv_to_adg(priv);	struct device *dev = rsnd_priv_to_dev(priv);	struct clk *clk;	int i;	u32 data;	int sel_table[] = {		[CLKA] = 0x1,		[CLKB] = 0x2,		[CLKC] = 0x3,		[CLKI] = 0x0,	};	dev_dbg(dev, "request clock = %d/n", rate);	/*	 * find suitable clock from	 * AUDIO_CLKA/AUDIO_CLKB/AUDIO_CLKC/AUDIO_CLKI.	 */	data = 0;	for_each_rsnd_clk(clk, adg, i) {		if (rate == clk_get_rate(clk)) {			data = sel_table[i];			goto found_clock;		}	}	/*	 * find divided clock from BRGA/BRGB	 */	if (rate  == adg->rbga_rate_for_441khz) {		data = 0x10;		goto found_clock;	}	if (rate == adg->rbgb_rate_for_48khz) {		data = 0x20;		goto found_clock;	}	return -EIO;found_clock:	/*	 * This "mod" = "ssi" here.	 * we can get "ssi id" from mod	 */	rsnd_adg_set_ssi_clk(mod, data);	dev_dbg(dev, "ADG: %s[%d] selects 0x%x for %d/n",		rsnd_mod_name(mod), rsnd_mod_id(mod),		data, rate);	return 0;}

/* *	SSI mod common functions */static int rsnd_ssi_init(struct rsnd_mod *mod,			 struct rsnd_dai *rdai,			 struct rsnd_dai_stream *io){	struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct device *dev = rsnd_priv_to_dev(priv);	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);	u32 cr;	cr = FORCE;	/*	 * always use 32bit system word for easy clock calculation.	 * see also rsnd_ssi_master_clk_enable()	 */	cr |= SWL_32;	/*	 * init clock settings for SSICR	 */	switch (runtime->sample_bits) {	case 16:		cr |= DWL_16;		break;	case 32:		cr |= DWL_24;		break;	default:		return -EIO;	}	if (rdai->bit_clk_inv)		cr |= SCKP;	if (rdai->frm_clk_inv)		cr |= SWSP;	if (rdai->data_alignment)		cr |= SDTA;	if (rdai->sys_delay)		cr |= DEL;	if (rsnd_dai_is_play(rdai, io))		cr |= TRMD;	/*	 * set ssi parameter	 */	ssi->rdai	= rdai;	ssi->io		= io;	ssi->cr_own	= cr;	ssi->err	= -1; /* ignore 1st error */	rsnd_ssi_mode_set(priv, rdai, ssi);	dev_dbg(dev, "%s.%d init/n", rsnd_mod_name(mod), rsnd_mod_id(mod));	return 0;}

	/*	 * Renesas sound Gen1 needs 1 DMAC,	 * Gen2 needs 2 DMAC.	 * In Gen2 case, it are Audio-DMAC, and Audio-DMAC-peri-peri.	 * But, Audio-DMAC-peri-peri doesn't have interrupt,	 * and this driver is assuming that here.	 *	 * If Audio-DMAC-peri-peri has interrpt,	 * rsnd_dai_pointer_update() will be called twice,	 * ant it will breaks io->byte_pos	 */	rsnd_dai_pointer_update(io, io->byte_per_period);}void rsnd_dma_start(struct rsnd_dma *dma){	struct rsnd_mod *mod = rsnd_dma_to_mod(dma);	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);	struct snd_pcm_substream *substream = io->substream;	struct device *dev = rsnd_priv_to_dev(priv);	struct dma_async_tx_descriptor *desc;	desc = dmaengine_prep_dma_cyclic(dma->chan,					 (dma->addr) ? dma->addr :					 substream->runtime->dma_addr,					 snd_pcm_lib_buffer_bytes(substream),					 snd_pcm_lib_period_bytes(substream),					 dma->dir,					 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);	if (!desc) {		dev_err(dev, "dmaengine_prep_slave_sg() fail/n");		return;	}	desc->callback		= rsnd_dma_complete;	desc->callback_param	= dma;	if (dmaengine_submit(desc) < 0) {		dev_err(dev, "dmaengine_submit() fail/n");		return;	}	dma_async_issue_pending(dma->chan);}int rsnd_dma_available(struct rsnd_dma *dma){	return !!dma->chan;}#define DMA_NAME_SIZE 16#define MOD_MAX 4 /* MEM/SSI/SRC/DVC */static int _rsnd_dma_of_name(char *dma_name, struct rsnd_mod *mod){	if (mod)		return snprintf(dma_name, DMA_NAME_SIZE / 2, "%s%d",			 rsnd_mod_dma_name(mod), rsnd_mod_id(mod));	else		return snprintf(dma_name, DMA_NAME_SIZE / 2, "mem");}

static int rsnd_src_start_gen1(struct rsnd_mod *mod,			       struct rsnd_dai *rdai){	int id = rsnd_mod_id(mod);	rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id));	return rsnd_src_start(mod, rdai);}

static int rsnd_src_stop_gen1(struct rsnd_mod *mod,			      struct rsnd_priv *priv){	int id = rsnd_mod_id(mod);	rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0);	return rsnd_src_stop(mod);}

int rsnd_ssiu_attach(struct rsnd_dai_stream *io,		     struct rsnd_mod *ssi_mod){	struct rsnd_priv *priv = rsnd_io_to_priv(io);	struct rsnd_mod *mod = rsnd_ssiu_mod_get(priv, rsnd_mod_id(ssi_mod));	rsnd_mod_confirm_ssi(ssi_mod);	return rsnd_dai_connect(mod, io, mod->type);}

static int rsnd_src_probe_gen1(struct rsnd_mod *mod,			       struct rsnd_priv *priv){	struct device *dev = rsnd_priv_to_dev(priv);	dev_dbg(dev, "%s[%d] (Gen1) is probed/n",		rsnd_mod_name(mod), rsnd_mod_id(mod));	return 0;}

static int rsnd_src_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_src_stop(mod, rdai, io);}

void rsnd_mod_make_sure(struct rsnd_mod *mod, enum rsnd_mod_type type){	if (mod->type != type) {		struct rsnd_priv *priv = rsnd_mod_to_priv(mod);		struct device *dev = rsnd_priv_to_dev(priv);		dev_warn(dev, "%s[%d] is not your expected module/n",			 rsnd_mod_name(mod), rsnd_mod_id(mod));	}}

static int rsnd_src_probe_gen2(struct rsnd_mod *mod,			       struct rsnd_dai *rdai){	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct rsnd_src *src = rsnd_mod_to_src(mod);	struct device *dev = rsnd_priv_to_dev(priv);	int ret;	ret = rsnd_dma_init(priv,			    rsnd_mod_to_dma(mod),			    rsnd_info_is_playback(priv, src),			    src->info->dma_id);	if (ret < 0)		dev_err(dev, "%s[%d] (Gen2) failed/n",			rsnd_mod_name(mod), rsnd_mod_id(mod));	else		dev_dbg(dev, "%s[%d] (Gen2) is probed/n",			rsnd_mod_name(mod), rsnd_mod_id(mod));	return ret;}

static int rsnd_src_probe_gen2(struct rsnd_mod *mod,			       struct rsnd_priv *priv){	struct rsnd_src *src = rsnd_mod_to_src(mod);	struct device *dev = rsnd_priv_to_dev(priv);	int irq = src->info->irq;	int ret;	if (irq > 0) {		/*		 * IRQ is not supported on non-DT		 * see		 *	rsnd_src_irq_enable_gen2()		 */		ret = devm_request_irq(dev, irq,				       rsnd_src_interrupt_gen2,				       IRQF_SHARED,				       dev_name(dev), mod);		if (ret)			goto rsnd_src_probe_gen2_fail;	}	ret = rsnd_dma_init(priv,			    rsnd_mod_to_dma(mod),			    rsnd_info_is_playback(priv, src),			    src->info->dma_id);	if (ret)		goto rsnd_src_probe_gen2_fail;	dev_dbg(dev, "%s[%d] (Gen2) is probed/n",		rsnd_mod_name(mod), rsnd_mod_id(mod));	return ret;rsnd_src_probe_gen2_fail:	dev_err(dev, "%s[%d] (Gen2) failed/n",		rsnd_mod_name(mod), rsnd_mod_id(mod));	return ret;}

static irqreturn_t rsnd_ssi_interrupt(int irq, void *data){	struct rsnd_ssi *ssi = data;	struct rsnd_mod *mod = &ssi->mod;	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);	int is_dma = rsnd_ssi_is_dma_mode(mod);	u32 status = rsnd_mod_read(mod, SSISR);	if (!io)		return IRQ_NONE;	/* PIO only */	if (!is_dma && (status & DIRQ)) {		struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);		u32 *buf = (u32 *)(runtime->dma_area +				   rsnd_dai_pointer_offset(io, 0));		/*		 * 8/16/32 data can be assesse to TDR/RDR register		 * directly as 32bit data		 * see rsnd_ssi_init()		 */		if (rsnd_io_is_play(io))			rsnd_mod_write(mod, SSITDR, *buf);		else			*buf = rsnd_mod_read(mod, SSIRDR);		rsnd_dai_pointer_update(io, sizeof(*buf));	}	/* PIO / DMA */	if (status & (UIRQ | OIRQ)) {		struct device *dev = rsnd_priv_to_dev(priv);		/*		 * restart SSI		 */		dev_dbg(dev, "%s[%d] restart/n",			rsnd_mod_name(mod), rsnd_mod_id(mod));		rsnd_ssi_stop(mod, priv);		if (ssi->err < 1024)			rsnd_ssi_start(mod, priv);		else			dev_warn(dev, "no more SSI restart/n");	}	rsnd_ssi_record_error(ssi, status);	return IRQ_HANDLED;}

static int rsnd_soc_dai_trigger(struct snd_pcm_substream *substream, int cmd,			    struct snd_soc_dai *dai){	struct rsnd_priv *priv = snd_soc_dai_get_drvdata(dai);	struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);	struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream);	int ssi_id = rsnd_mod_id(rsnd_io_to_mod_ssi(io));	int ret;	unsigned long flags;	rsnd_lock(priv, flags);	switch (cmd) {	case SNDRV_PCM_TRIGGER_START:		ret = rsnd_dai_stream_init(io, substream);		if (ret < 0)			goto dai_trigger_end;		ret = rsnd_platform_call(priv, dai, start, ssi_id);		if (ret < 0)			goto dai_trigger_end;		ret = rsnd_dai_call(init, io, priv);		if (ret < 0)			goto dai_trigger_end;		ret = rsnd_dai_call(start, io, priv);		if (ret < 0)			goto dai_trigger_end;		break;	case SNDRV_PCM_TRIGGER_STOP:		ret = rsnd_dai_call(stop, io, priv);		if (ret < 0)			goto dai_trigger_end;		ret = rsnd_dai_call(quit, io, priv);		if (ret < 0)			goto dai_trigger_end;		ret = rsnd_platform_call(priv, dai, stop, ssi_id);		if (ret < 0)			goto dai_trigger_end;		break;	default:		ret = -EINVAL;	}dai_trigger_end:	rsnd_unlock(priv, flags);	return ret;}