static int rsnd_src_set_convert_rate(struct rsnd_mod *mod) { 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); u32 fsrate = 0; if (convert_rate) fsrate = 0x0400000 / convert_rate * runtime->rate; /* set/clear soft reset */ rsnd_mod_write(mod, SRC_SWRSR, 0); rsnd_mod_write(mod, SRC_SWRSR, 1); /* Set channel number and output bit length */ rsnd_mod_write(mod, SRC_ADINR, rsnd_get_adinr(mod)); /* Enable the initial value of IFS */ if (fsrate) { rsnd_mod_write(mod, SRC_IFSCR, 1); /* Set initial value of IFS */ rsnd_mod_write(mod, SRC_IFSVR, fsrate); } /* use DMA transfer */ rsnd_mod_write(mod, SRC_BUSIF_MODE, 1); return 0; }
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); }
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; }
static int rsnd_src_quit(struct rsnd_mod *mod, struct rsnd_dai *rdai) { struct rsnd_src *src = rsnd_mod_to_src(mod); clk_disable_unprepare(src->clk); return 0; }
static int rsnd_src_init(struct rsnd_mod *mod, struct rsnd_dai *rdai) { struct rsnd_src *src = rsnd_mod_to_src(mod); clk_prepare_enable(src->clk); return 0; }
static int rsnd_src_stop(struct rsnd_mod *mod, struct rsnd_dai *rdai) { struct rsnd_src *src = rsnd_mod_to_src(mod); if (rsnd_src_convert_rate(src)) rsnd_mod_write(mod, SRC_ROUTE_MODE0, 0); return 0; }
static int rsnd_src_stop_gen2(struct rsnd_mod *mod, struct rsnd_dai *rdai) { struct rsnd_src *src = rsnd_mod_to_src(mod); rsnd_mod_write(mod, SRC_CTRL, 0); rsnd_dma_stop(rsnd_mod_to_dma(&src->mod)); return rsnd_src_stop(mod, rdai); }
static int rsnd_src_start_gen2(struct rsnd_mod *mod, struct rsnd_dai *rdai, struct rsnd_dai_stream *io) { struct rsnd_src *src = rsnd_mod_to_src(mod); rsnd_dma_start(rsnd_mod_to_dma(&src->mod)); rsnd_mod_write(mod, SSI_CTRL, 0x1); rsnd_mod_write(mod, SRC_CTRL, 0x11); return rsnd_src_start(mod, rdai, io); }
static int rsnd_src_start_gen2(struct rsnd_mod *mod, struct rsnd_dai *rdai) { struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); struct rsnd_src *src = rsnd_mod_to_src(mod); u32 val = rsnd_io_to_mod_dvc(io) ? 0x01 : 0x11; rsnd_dma_start(rsnd_mod_to_dma(&src->mod)); rsnd_mod_write(mod, SRC_CTRL, val); return rsnd_src_start(mod, rdai); }
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_src_quit(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); rsnd_mod_hw_stop(mod); if (src->err) dev_warn(dev, "%s[%d] under/over flow err = %d\n", rsnd_mod_name(mod), rsnd_mod_id(mod), src->err); return 0; }
static int rsnd_src_set_convert_rate(struct rsnd_mod *mod, struct rsnd_dai *rdai, struct rsnd_dai_stream *io) { 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); u32 adinr = runtime->channels; u32 fsrate = 0; if (convert_rate) fsrate = 0x0400000 / convert_rate * runtime->rate; /* set/clear soft reset */ rsnd_mod_write(mod, SRC_SWRSR, 0); rsnd_mod_write(mod, SRC_SWRSR, 1); /* * Initialize the operation of the SRC internal circuits * see rsnd_src_start() */ rsnd_mod_write(mod, SRC_SRCIR, 1); /* Set channel number and output bit length */ switch (runtime->sample_bits) { case 16: adinr |= OTBL_16; break; case 32: adinr |= OTBL_24; break; default: return -EIO; } rsnd_mod_write(mod, SRC_ADINR, adinr); /* Enable the initial value of IFS */ if (fsrate) { rsnd_mod_write(mod, SRC_IFSCR, 1); /* Set initial value of IFS */ rsnd_mod_write(mod, SRC_IFSVR, fsrate); } /* use DMA transfer */ rsnd_mod_write(mod, SRC_BUSIF_MODE, 1); 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; }
static int rsnd_src_start(struct rsnd_mod *mod, struct rsnd_dai *rdai) { struct rsnd_src *src = rsnd_mod_to_src(mod); /* * Cancel the initialization and operate the SRC function * see rsnd_src_set_convert_rate() */ rsnd_mod_write(mod, SRC_SRCIR, 0); if (rsnd_src_convert_rate(src)) rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1); return 0; }
static int rsnd_src_init(struct rsnd_mod *mod) { struct rsnd_src *src = rsnd_mod_to_src(mod); rsnd_mod_hw_start(mod); src->err = 0; /* * Initialize the operation of the SRC internal circuits * see rsnd_src_start() */ rsnd_mod_write(mod, SRC_SRCIR, 1); return 0; }
static int rsnd_src_set_convert_timing_gen2(struct rsnd_mod *mod) { 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); int ret; if (convert_rate) ret = rsnd_adg_set_convert_clk_gen2(mod, io, runtime->rate, convert_rate); else ret = rsnd_adg_set_convert_timing_gen2(mod, io); return ret; }
static bool rsnd_src_error_record_gen2(struct rsnd_mod *mod) { u32 val = OUF_SRC(rsnd_mod_id(mod)); bool ret = false; if ((rsnd_mod_read(mod, SCU_SYS_STATUS0) & val) || (rsnd_mod_read(mod, SCU_SYS_STATUS1) & val)) { struct rsnd_src *src = rsnd_mod_to_src(mod); src->err++; ret = true; } /* clear error static */ rsnd_src_error_clear_gen2(mod); return ret; }
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, "SRC DMA failed\n"); dev_dbg(dev, "%s (Gen2) is probed\n", rsnd_mod_name(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; }
unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv, struct rsnd_dai_stream *io, struct snd_pcm_runtime *runtime) { struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io); struct rsnd_src *src; unsigned int rate = 0; if (src_mod) { src = rsnd_mod_to_src(src_mod); /* * return convert rate if SRC is used, * otherwise, return runtime->rate as usual */ rate = rsnd_src_convert_rate(src); } if (!rate) rate = runtime->rate; return rate; }
static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod) { struct rsnd_src *src = rsnd_mod_to_src(mod); int ret; ret = rsnd_src_set_convert_rate(mod); if (ret < 0) return ret; /* Select SRC mode (fixed value) */ rsnd_mod_write(mod, SRC_SRCCR, 0x00010110); /* Set the restriction value of the FS ratio (98%) */ rsnd_mod_write(mod, SRC_MNFSR, rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98); /* Gen1/Gen2 are not compatible */ if (rsnd_src_convert_rate(src)) rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1); /* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */ return 0; }