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

static void rsnd_dmaen_start(struct rsnd_dai_stream *io, struct rsnd_dma *dma){	struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma);	struct rsnd_mod *mod = rsnd_dma_to_mod(dma);	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct snd_pcm_substream *substream = io->substream;	struct device *dev = rsnd_priv_to_dev(priv);	struct dma_async_tx_descriptor *desc;	int is_play = rsnd_io_is_play(io);	desc = dmaengine_prep_dma_cyclic(dmaen->chan,					 substream->runtime->dma_addr,					 snd_pcm_lib_buffer_bytes(substream),					 snd_pcm_lib_period_bytes(substream),					 is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM,					 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);	if (!desc) {		dev_err(dev, "dmaengine_prep_slave_sg() fail/n");		return;	}	desc->callback		= rsnd_dmaen_complete;	desc->callback_param	= mod;	if (dmaengine_submit(desc) < 0) {		dev_err(dev, "dmaengine_submit() fail/n");		return;	}	dma_async_issue_pending(dmaen->chan);}

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

/* *		Audio DMAC */static void __rsnd_dmaen_complete(struct rsnd_mod *mod,				  struct rsnd_dai_stream *io){	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	bool elapsed = false;	unsigned long flags;	/*	 * 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	 */	spin_lock_irqsave(&priv->lock, flags);	if (rsnd_io_is_working(io))		elapsed = rsnd_dai_pointer_update(io, io->byte_per_period);	spin_unlock_irqrestore(&priv->lock, flags);	if (elapsed)		rsnd_dai_period_elapsed(io);}

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 int rsnd_src_remove_gen2(struct rsnd_mod *mod,				struct rsnd_dai *rdai){	rsnd_dma_quit(rsnd_mod_to_priv(mod), rsnd_mod_to_dma(mod));	return 0;}

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

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

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

/* *		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 struct dma_chan *rsnd_dvc_dma_req(struct rsnd_dai_stream *io,					 struct rsnd_mod *mod){	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	return rsnd_dma_request_channel(rsnd_dvc_of_node(priv),					mod, "tx");}

static int rsnd_ssi_dma_remove(struct rsnd_mod *mod,			       struct rsnd_dai *rdai,			       struct rsnd_dai_stream *io){	rsnd_dma_quit(rsnd_mod_to_priv(mod), rsnd_mod_to_dma(mod));	return 0;}

static u32 rsnd_dmapp_read(struct rsnd_dma *dma, u32 reg){	struct rsnd_mod *mod = rsnd_mod_get(dma);	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);	return ioread32(rsnd_dmapp_addr(dmac, dma, reg));}

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

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

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

void rsnd_dma_quit(struct rsnd_dai_stream *io, struct rsnd_dma *dma){	struct rsnd_mod *mod = rsnd_dma_to_mod(dma);	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);	if (!dmac)		return;	dma->ops->quit(io, dma);}

/* *		Non SSI */static int rsnd_ssi_non(struct rsnd_mod *mod,			struct rsnd_dai *rdai,			struct rsnd_dai_stream *io){	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct device *dev = rsnd_priv_to_dev(priv);	dev_dbg(dev, "%s/n", __func__);	return 0;}

int rsnd_src_enable_ssi_irq(struct rsnd_mod *ssi_mod,			    struct rsnd_dai *rdai){	struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);	/* enable PIO interrupt if Gen2 */	if (rsnd_is_gen2(priv))		rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0f000000);	return 0;}

static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg){	struct rsnd_mod *mod = rsnd_mod_get(dma);	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv);	struct device *dev = rsnd_priv_to_dev(priv);	dev_dbg(dev, "w %p : %08x/n", rsnd_dmapp_addr(dmac, dma, reg), data);	iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg));}

int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod){	struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);	if (rsnd_is_gen1(priv))		return 0;	/* disable SSI interrupt if Gen2 */	rsnd_mod_write(ssi_mod, INT_ENABLE, 0x00000000);	return 0;}

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

int rsnd_adg_set_src_timesel_gen2(struct rsnd_mod *src_mod,				  struct rsnd_dai_stream *io,				  unsigned int in_rate,				  unsigned int out_rate){	struct rsnd_priv *priv = rsnd_mod_to_priv(src_mod);	struct rsnd_adg *adg = rsnd_priv_to_adg(priv);	struct rsnd_mod *adg_mod = rsnd_mod_get(adg);	u32 in, out;	u32 mask, en;	int id = rsnd_mod_id(src_mod);	int shift = (id % 2) ? 16 : 0;	rsnd_mod_confirm_src(src_mod);	rsnd_adg_get_timesel_ratio(priv, io,				   in_rate, out_rate,				   &in, &out, &en);	in   = in	<< shift;	out  = out	<< shift;	mask = 0xffff	<< shift;	switch (id / 2) {	case 0:		rsnd_mod_bset(adg_mod, SRCIN_TIMSEL0,  mask, in);		rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL0, mask, out);		break;	case 1:		rsnd_mod_bset(adg_mod, SRCIN_TIMSEL1,  mask, in);		rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL1, mask, out);		break;	case 2:		rsnd_mod_bset(adg_mod, SRCIN_TIMSEL2,  mask, in);		rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL2, mask, out);		break;	case 3:		rsnd_mod_bset(adg_mod, SRCIN_TIMSEL3,  mask, in);		rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL3, mask, out);		break;	case 4:		rsnd_mod_bset(adg_mod, SRCIN_TIMSEL4,  mask, in);		rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL4, mask, out);		break;	}	if (en)		rsnd_mod_bset(adg_mod, DIV_EN, en, en);	return 0;}

static void __rsnd_ssi_interrupt(struct rsnd_mod *mod,				 struct rsnd_dai_stream *io){	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	int is_dma = rsnd_ssi_is_dma_mode(mod);	u32 status;	bool elapsed = false;	bool stop = false;	spin_lock(&priv->lock);	/* ignore all cases if not working */	if (!rsnd_io_is_working(io))		goto rsnd_ssi_interrupt_out;	status = rsnd_ssi_status_get(mod);	/* 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);		elapsed = rsnd_dai_pointer_update(io, sizeof(*buf));	}	/* DMA only */	if (is_dma && (status & (UIRQ | OIRQ)))		stop = true;	rsnd_ssi_status_clear(mod);rsnd_ssi_interrupt_out:	spin_unlock(&priv->lock);	if (elapsed)		rsnd_dai_period_elapsed(io);	if (stop)		snd_pcm_stop_xrun(io->substream);}

static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod){	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct device *dev = rsnd_priv_to_dev(priv);	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);	struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);	struct rsnd_src *src = rsnd_mod_to_src(mod);	u32 convert_rate = rsnd_src_convert_rate(src);	uint ratio;	int ret;	/* 6 - 1/6 are very enough ratio for SRC_BSDSR */	if (!convert_rate)		ratio = 0;	else if (convert_rate > runtime->rate)		ratio = 100 * convert_rate / runtime->rate;	else		ratio = 100 * runtime->rate / convert_rate;	if (ratio > 600) {		dev_err(dev, "FSO/FSI ratio error/n");		return -EINVAL;	}	ret = rsnd_src_set_convert_rate(mod);	if (ret < 0)		return ret;	rsnd_mod_write(mod, SRC_SRCCR, 0x00011110);	if (convert_rate) {		/* Gen1/Gen2 are not compatible */		rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);	}	switch (rsnd_mod_id(mod)) {	case 5:	case 6:	case 7:	case 8:		rsnd_mod_write(mod, SRC_BSDSR, 0x02400000);		break;	default:		rsnd_mod_write(mod, SRC_BSDSR, 0x01800000);		break;	}	rsnd_mod_write(mod, SRC_BSISR, 0x00100060);	return 0;}

static int rsnd_adg_set_src_timsel_gen2(struct rsnd_mod *src_mod,					struct rsnd_dai_stream *io,					u32 timsel){	struct rsnd_priv *priv = rsnd_mod_to_priv(src_mod);	struct rsnd_adg *adg = rsnd_priv_to_adg(priv);	struct rsnd_mod *adg_mod = rsnd_mod_get(adg);	int is_play = rsnd_io_is_play(io);	int id = rsnd_mod_id(src_mod);	int shift = (id % 2) ? 16 : 0;	u32 mask, ws;	u32 in, out;	rsnd_mod_confirm_src(src_mod);	ws = rsnd_adg_ssi_ws_timing_gen2(io);	in  = (is_play) ? timsel : ws;	out = (is_play) ? ws     : timsel;	in   = in	<< shift;	out  = out	<< shift;	mask = 0xffff	<< shift;	switch (id / 2) {	case 0:		rsnd_mod_bset(adg_mod, SRCIN_TIMSEL0,  mask, in);		rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL0, mask, out);		break;	case 1:		rsnd_mod_bset(adg_mod, SRCIN_TIMSEL1,  mask, in);		rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL1, mask, out);		break;	case 2:		rsnd_mod_bset(adg_mod, SRCIN_TIMSEL2,  mask, in);		rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL2, mask, out);		break;	case 3:		rsnd_mod_bset(adg_mod, SRCIN_TIMSEL3,  mask, in);		rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL3, mask, out);		break;	case 4:		rsnd_mod_bset(adg_mod, SRCIN_TIMSEL4,  mask, in);		rsnd_mod_bset(adg_mod, SRCOUT_TIMSEL4, mask, out);		break;	}	return 0;}

/* *		Gen1/Gen2 common functions */int rsnd_src_ssi_mode_init(struct rsnd_mod *ssi_mod,			   struct rsnd_dai *rdai,			   struct rsnd_dai_stream *io){	struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);	struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io);	struct rcar_snd_info *info = rsnd_priv_to_info(priv);	int ssi_id = rsnd_mod_id(ssi_mod);	int has_src = 0;	/*	 * SSI_MODE0	 */	if (info->dai_info) {		has_src = !!src_mod;	} else {		struct rsnd_src *src = rsnd_mod_to_src(src_mod);		has_src = rsnd_src_hpbif_is_enable(src);	}	rsnd_mod_bset(ssi_mod, SSI_MODE0, (1 << ssi_id),		      has_src ? 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(ssi_mod, SSI_MODE1,				      0x3 << shift,				      rsnd_dai_is_clk_master(rdai) ?				      0x2 << shift : 0x1 << shift);	}	return 0;}

int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod){	struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);	if (rsnd_is_gen1(priv))		return 0;	/* enable SSI interrupt if Gen2 */	if (rsnd_ssi_is_dma_mode(ssi_mod))		rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0e000000);	else		rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0f000000);	return 0;}

static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_mod *mod){	struct rsnd_priv *priv = rsnd_mod_to_priv(mod);	struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);	int is_play = rsnd_io_is_play(io);	char *name;	if (rsnd_ssi_use_busif(mod))		name = is_play ? "rxu" : "txu";	else		name = is_play ? "rx" : "tx";	return rsnd_dma_request_channel(rsnd_ssi_of_node(priv),					mod, name);}