static int s3c2412_i2s_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *cpu_dai) { struct s3c_i2sv2_info *i2s = snd_soc_dai_get_drvdata(cpu_dai); struct s3c_dma_params *dma_data; u32 iismod; pr_debug("Entered %s\n", __func__); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) dma_data = i2s->dma_playback; else dma_data = i2s->dma_capture; snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data); iismod = readl(i2s->regs + S3C2412_IISMOD); pr_debug("%s: r: IISMOD: %x\n", __func__, iismod); switch (params_format(params)) { case SNDRV_PCM_FORMAT_S8: iismod |= S3C2412_IISMOD_8BIT; break; case SNDRV_PCM_FORMAT_S16_LE: iismod &= ~S3C2412_IISMOD_8BIT; break; } writel(iismod, i2s->regs + S3C2412_IISMOD); pr_debug("%s: w: IISMOD: %x\n", __func__, iismod); return 0; }
static int pxa3xx_ssp_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai; struct ssp_device *ssp; int ret = 0; u32 sscr0; if (!cpu_dai->active) { ret = ssp_init(&ssp_dev[cpu_dai->id], cpu_dai->id + 1, SSP_NO_IRQ); if(ret) return ret; ssp = ssp_dev[cpu_dai->id].ssp; sscr0 = __raw_readl(ssp->mmio_base + SSCR0); sscr0 &= ~SSCR0_SSE; __raw_writel(sscr0, ssp->mmio_base + SSCR0); cpu_dai->private_data = ssp; } kfree(snd_soc_dai_get_dma_data(cpu_dai, substream)); snd_soc_dai_set_dma_data(cpu_dai, substream, NULL); return ret; }
static int au1xpsc_i2s_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct au1xpsc_audio_data *pscdata = snd_soc_dai_get_drvdata(dai); snd_soc_dai_set_dma_data(dai, substream, &pscdata->dmaids[0]); return 0; }
static int omap_hdmi_dai_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { int err = 0; switch (params_format(params)) { case SNDRV_PCM_FORMAT_S16_LE: omap_hdmi_dai_dma_params.packet_size = 16; break; case SNDRV_PCM_FORMAT_S24_LE: omap_hdmi_dai_dma_params.packet_size = 32; break; default: err = -EINVAL; } omap_hdmi_dai_dma_params.data_type = OMAP_DMA_DATA_TYPE_S32; snd_soc_dai_set_dma_data(dai, substream, &omap_hdmi_dai_dma_params); err = hdmi_lib_start_acr_wa(); if (err) pr_warning("Failed to start ACR workaround[%d]]\n", err); return err; }
static int hdmi_dai_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct hdmi_audio_data *ad = card_drvdata_substream(substream); int ret; /* * Make sure that the period bytes are multiple of the DMA packet size. * Largest packet size we use is 32 32-bit words = 128 bytes */ ret = snd_pcm_hw_constraint_step(substream->runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 128); if (ret < 0) { dev_err(dai->dev, "could not apply constraint\n"); return ret; } snd_soc_dai_set_dma_data(dai, substream, &ad->dma_data); mutex_lock(&ad->current_stream_lock); ad->current_stream = substream; mutex_unlock(&ad->current_stream_lock); ret = ad->ops->audio_startup(ad->dssdev, hdmi_dai_abort); if (ret) { mutex_lock(&ad->current_stream_lock); ad->current_stream = NULL; mutex_unlock(&ad->current_stream_lock); } return ret; }
static int mxs_spdif_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai; int playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0; int irq; int ret; if (playback) { irq = IRQ_SPDIF_ERROR; snd_soc_dai_set_dma_data(cpu_dai, substream, &mxs_spdif); } ret = request_irq(irq, mxs_err_irq, 0, "Mxs SPDIF Error", substream); if (ret) { printk(KERN_ERR "%s: Unable to request SPDIF error irq %d\n", __func__, IRQ_SPDIF_ERROR); return ret; } /* Enable error interrupt */ if (playback) { __raw_writel(BM_SPDIF_CTRL_FIFO_OVERFLOW_IRQ, REGS_SPDIF_BASE + HW_SPDIF_CTRL_CLR); __raw_writel(BM_SPDIF_CTRL_FIFO_UNDERFLOW_IRQ, REGS_SPDIF_BASE + HW_SPDIF_CTRL_CLR); __raw_writel(BM_SPDIF_CTRL_FIFO_ERROR_IRQ_EN, REGS_SPDIF_BASE + HW_SPDIF_CTRL_SET); } return 0; }
static int skl_link_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct hdac_ext_bus *ebus = dev_get_drvdata(dai->dev); struct hdac_ext_stream *link_dev; struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream); struct hdac_ext_dma_params *dma_params; struct snd_soc_dai *codec_dai = rtd->codec_dai; struct skl_pipe_params p_params = {0}; link_dev = snd_hdac_ext_stream_assign(ebus, substream, HDAC_EXT_STREAM_TYPE_LINK); if (!link_dev) return -EBUSY; snd_soc_dai_set_dma_data(dai, substream, (void *)link_dev); /* set the stream tag in the codec dai dma params */ dma_params = snd_soc_dai_get_dma_data(codec_dai, substream); if (dma_params) dma_params->stream_tag = hdac_stream(link_dev)->stream_tag; p_params.s_fmt = snd_pcm_format_width(params_format(params)); p_params.ch = params_channels(params); p_params.s_freq = params_rate(params); p_params.stream = substream->stream; p_params.link_dma_id = hdac_stream(link_dev)->stream_tag - 1; return skl_tplg_be_update_params(dai, &p_params); }
static void skl_pcm_close(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct hdac_ext_stream *stream = get_hdac_ext_stream(substream); struct hdac_ext_bus *ebus = dev_get_drvdata(dai->dev); struct skl_dma_params *dma_params = NULL; struct skl *skl = ebus_to_skl(ebus); dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name); snd_hdac_ext_stream_release(stream, skl_get_host_stream_type(ebus)); dma_params = snd_soc_dai_get_dma_data(dai, substream); /* * now we should set this to NULL as we are freeing by the * dma_params */ snd_soc_dai_set_dma_data(dai, substream, NULL); skl_set_suspend_active(substream, dai, false); /* * check if close is for "Reference Pin" and set back the * CGCTL.MISCBDCGE if disabled by driver */ if (!strncmp(dai->name, "Reference Pin", 13) && skl->skl_sst->miscbdcg_disabled) { skl->skl_sst->enable_miscbdcge(dai->dev, true); skl->skl_sst->miscbdcg_disabled = false; } kfree(dma_params); }
static int tcc_i2s_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_dai *cpu_dai = rtd->cpu_dai; struct tcc_pcm_dma_params *dma_data; if (substream->pcm->device == __I2S_DEV_NUM__) { if(substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { dma_data = &tcc_i2s_pcm_stereo_out; } else if(substream->stream == SNDRV_PCM_STREAM_CAPTURE) { dma_data = &tcc_i2s_pcm_stereo_in; } snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data); // Set DAI clock tcc_i2s_set_clock(params_rate(params)); } alsa_dbg("=====================\n"); alsa_dbg("= rate : %d\n", params_rate(params)); alsa_dbg("= channels : %d\n", params_channels(params)); alsa_dbg("= period_size : %d\n", params_period_size(params)); return 0; }
static int alchemy_ac97c_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct au1xpsc_audio_data *ctx = snd_soc_dai_get_drvdata(dai); snd_soc_dai_set_dma_data(dai, substream, &ctx->dmaids[0]); return 0; }
static int sunxi_hdmiaudio_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct snd_soc_pcm_runtime *rtd = NULL; struct sunxi_dma_params *dma_data = NULL; u32 reg_val = 0; switch (params_format(params)) { case SNDRV_PCM_FORMAT_S16_LE: sample_resolution = 16; break; case SNDRV_PCM_FORMAT_S20_3LE: sample_resolution = 24; break; case SNDRV_PCM_FORMAT_S24_LE: sample_resolution = 24; break; case SNDRV_PCM_FORMAT_S32_LE: sample_resolution = 24; break; default: return -EINVAL; } if (!substream) { printk("error:%s,line:%d\n", __func__, __LINE__); return -EAGAIN; } reg_val = readl(sunxi_i2s1.regs + SUNXI_I2S1FAT0); sunxi_i2s1.samp_res = sample_resolution; reg_val &= ~SUNXI_I2S1FAT0_SR_RVD; if(sunxi_i2s1.samp_res == 16) reg_val |= SUNXI_I2S1FAT0_SR_16BIT; else if(sunxi_i2s1.samp_res == 20) reg_val |= SUNXI_I2S1FAT0_SR_20BIT; else reg_val |= SUNXI_I2S1FAT0_SR_24BIT; writel(reg_val, sunxi_i2s1.regs + SUNXI_I2S1FAT0); rtd = substream->private_data; if (sample_resolution == 24) { reg_val = readl(sunxi_i2s1.regs + SUNXI_I2S1FCTL); reg_val &= ~(0x1<<2); writel(reg_val, sunxi_i2s1.regs + SUNXI_I2S1FCTL); } if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { dma_data = &sunxi_hdmiaudio_pcm_stereo_out; } else { printk("error:hdmiaudio can't support capture:%s,line:%d\n", __func__, __LINE__); } snd_soc_dai_set_dma_data(rtd->cpu_dai, substream, dma_data); return 0; }
static int jz_spdif_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { int channels = params_channels(params); int fmt_width = snd_pcm_format_width(params_format(params)); struct jz_spdif *jz_spdif = dev_get_drvdata(dai->dev); struct device *aic = jz_spdif->aic; struct jz_aic *jz_aic = dev_get_drvdata(aic); enum dma_slave_buswidth buswidth; int trigger; unsigned long sample_rate = params_rate(params); spdif_DEBUG_MSG("enter %s, substream = %s\n", __func__, (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? "playback" : "capture"); if (!((1 << params_format(params)) & JZ_SPDIF_FORMATS) || channels > 2) { dev_err(dai->dev, "hw params not inval channel %d params %x\n", channels, params_format(params)); return -EINVAL; } if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { __i2s_channel(aic, channels); /* format */ if (fmt_width == 16){ buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES; __spdif_set_max_wl(aic,0); __spdif_set_sample_size(aic,1); }else if(fmt_width == 24){ buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES; __spdif_set_max_wl(aic,1); __spdif_set_sample_size(aic,5); }else{ return -EINVAL; } jz_spdif->tx_dma_data.buswidth = buswidth; jz_spdif->tx_dma_data.max_burst = (SPDIF_TFIFO_DEPTH * buswidth)/2; trigger = SPDIF_TFIFO_DEPTH - (jz_spdif->tx_dma_data.max_burst/(int)buswidth); __i2s_set_transmit_trigger(aic,trigger/2); snd_soc_dai_set_dma_data(dai, substream, (void *)&jz_spdif->tx_dma_data); } else { printk("spdif is not a capture device!\n"); return -EINVAL; } /* sample rate */ unsigned long tmp_rate = 0; tmp_rate = jz_spdif_set_rate(aic,jz_aic,sample_rate); if(tmp_rate < 0) printk("set spdif clk failed!!\n"); /* signed transfer */ if(snd_pcm_format_signed(params_format(params))) __spdif_clear_signn(aic); else __spdif_set_signn(aic); return 0; }
static int davinci_i2s_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct davinci_mcbsp_dev *dev = snd_soc_dai_get_drvdata(dai); snd_soc_dai_set_dma_data(dai, substream, dev->dma_params); return 0; }
static int kirkwood_i2s_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai); snd_soc_dai_set_dma_data(dai, substream, priv); return 0; }
/* * Set the SSPA audio DMA parameters and sample size. * Can be called multiple times by oss emulation. */ static int mmp_sspa_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_dai *cpu_dai = rtd->cpu_dai; struct sspa_priv *sspa_priv = snd_soc_dai_get_drvdata(dai); struct ssp_device *sspa = sspa_priv->sspa; struct snd_dmaengine_dai_dma_data *dma_params; u32 sspa_ctrl; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) sspa_ctrl = mmp_sspa_read_reg(sspa, SSPA_TXCTL); else sspa_ctrl = mmp_sspa_read_reg(sspa, SSPA_RXCTL); sspa_ctrl &= ~SSPA_CTL_XFRLEN1_MASK; sspa_ctrl |= SSPA_CTL_XFRLEN1(params_channels(params) - 1); sspa_ctrl &= ~SSPA_CTL_XWDLEN1_MASK; sspa_ctrl |= SSPA_CTL_XWDLEN1(SSPA_CTL_32_BITS); sspa_ctrl &= ~SSPA_CTL_XSSZ1_MASK; switch (params_format(params)) { case SNDRV_PCM_FORMAT_S8: sspa_ctrl |= SSPA_CTL_XSSZ1(SSPA_CTL_8_BITS); break; case SNDRV_PCM_FORMAT_S16_LE: sspa_ctrl |= SSPA_CTL_XSSZ1(SSPA_CTL_16_BITS); break; case SNDRV_PCM_FORMAT_S20_3LE: sspa_ctrl |= SSPA_CTL_XSSZ1(SSPA_CTL_20_BITS); break; case SNDRV_PCM_FORMAT_S24_3LE: sspa_ctrl |= SSPA_CTL_XSSZ1(SSPA_CTL_24_BITS); break; case SNDRV_PCM_FORMAT_S32_LE: sspa_ctrl |= SSPA_CTL_XSSZ1(SSPA_CTL_32_BITS); break; default: return -EINVAL; } if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { mmp_sspa_write_reg(sspa, SSPA_TXCTL, sspa_ctrl); mmp_sspa_write_reg(sspa, SSPA_TXFIFO_LL, 0x1); } else { mmp_sspa_write_reg(sspa, SSPA_RXCTL, sspa_ctrl); mmp_sspa_write_reg(sspa, SSPA_RXFIFO_UL, 0x0); } dma_params = &sspa_priv->dma_params[substream->stream]; dma_params->addr = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? (sspa->phys_base + SSPA_TXD) : (sspa->phys_base + SSPA_RXD); snd_soc_dai_set_dma_data(cpu_dai, substream, dma_params); return 0; }
/* * snd_soc_dai_ops */ static int nxp_spdif_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct nxp_spdif_snd_param *par = snd_soc_dai_get_drvdata(dai); struct nxp_pcm_dma_param *dmap = &par->dma; snd_soc_dai_set_dma_data(dai, substream, dmap); return 0; }
static int s3c_i2sv4_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *cpu_dai) { struct s3c_i2sv2_info *i2s = to_info(cpu_dai); struct s3c_dma_params *dma_data; u32 iismod; u32 dma_tsfr_size = 0; dev_dbg(cpu_dai->dev, "Entered %s\n", __func__); /* TODO */ switch (params_channels(params)) { case 1: dma_tsfr_size = 2; break; case 2: dma_tsfr_size = 4; break; case 4: break; case 6: break; default: break; } if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { dma_data = i2s->dma_playback; i2s->dma_playback->dma_size = dma_tsfr_size; } else { dma_data = i2s->dma_capture; i2s->dma_capture->dma_size = dma_tsfr_size; } snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data); iismod = readl(i2s->regs + S3C2412_IISMOD); dev_dbg(cpu_dai->dev, "%s: r: IISMOD: %x\n", __func__, iismod); iismod &= ~S3C64XX_IISMOD_BLC_MASK; switch (params_format(params)) { case SNDRV_PCM_FORMAT_S8: iismod |= S3C64XX_IISMOD_BLC_8BIT; break; case SNDRV_PCM_FORMAT_S16_LE: break; case SNDRV_PCM_FORMAT_S24_LE: iismod |= S3C64XX_IISMOD_BLC_24BIT; break; } writel(iismod, i2s->regs + S3C2412_IISMOD); dev_dbg(cpu_dai->dev, "%s: w: IISMOD: %x\n", __func__, iismod); return 0; }
static int jz_pcm_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct device *dev = dai->dev; struct jz_pcm *jz_pcm = dev_get_drvdata(dai->dev); int fmt_width = snd_pcm_format_width(params_format(params)); enum dma_slave_buswidth buswidth; int trigger; PCM_DEBUG_MSG("enter %s, substream = %s\n", __func__, (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? "playback" : "capture"); if (!((1 << params_format(params)) & JZ_PCM_FORMATS) || params_channels(params) != 1 || params_rate(params) != 8000) { dev_err(dai->dev, "hw params not inval channel %d params %x\n", params_channels(params), params_format(params)); return -EINVAL; } /* format 8 bit or 16 bit*/ if (fmt_width == 8) buswidth = DMA_SLAVE_BUSWIDTH_1_BYTE; else buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { jz_pcm->tx_dma_data.buswidth = buswidth; jz_pcm->tx_dma_data.max_burst = (PCM_TFIFO_DEPTH * buswidth)/2; trigger = PCM_TFIFO_DEPTH - (jz_pcm->tx_dma_data.max_burst/(int)buswidth); __pcm_set_oss_sample_size(dev, fmt_width == 8 ? 0 : 1); __pcm_set_transmit_trigger(dev, trigger); snd_soc_dai_set_dma_data(dai, substream, (void *)&jz_pcm->tx_dma_data); } else { jz_pcm->rx_dma_data.buswidth = buswidth; jz_pcm->rx_dma_data.max_burst = (PCM_RFIFO_DEPTH * buswidth)/2; trigger = jz_pcm->rx_dma_data.max_burst/(int)buswidth; __pcm_set_iss_sample_size(dev, fmt_width == 8 ? 0 : 1); __pcm_set_receive_trigger(dev, trigger); snd_soc_dai_set_dma_data(dai, substream, (void *)&jz_pcm->rx_dma_data); } return 0; }
int sunxi_daudio0_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct snd_soc_pcm_runtime *rtd = substream->private_data; struct sunxi_dma_params *dma_data; u32 reg_val = 0; switch (params_format(params)) { case SNDRV_PCM_FORMAT_S16_LE: sample_resolution = 16; break; case SNDRV_PCM_FORMAT_S20_3LE: sample_resolution = 24; break; case SNDRV_PCM_FORMAT_S24_LE: sample_resolution = 24; break; case SNDRV_PCM_FORMAT_S32_LE: sample_resolution = 24; break; default: return -EINVAL; } reg_val = sunxi_smc_readl(sunxi_daudio.regs + SUNXI_DAUDIOFAT0); sunxi_daudio.samp_res = sample_resolution; reg_val &= ~SUNXI_DAUDIOFAT0_SR; if(sample_resolution == 16) reg_val |= (3<<4); else if(sample_resolution == 20) reg_val |= (4<<4); else reg_val |= (5<<4); sunxi_smc_writel(reg_val, sunxi_daudio.regs + SUNXI_DAUDIOFAT0); if (sample_resolution == 24) { reg_val = sunxi_smc_readl(sunxi_daudio.regs + SUNXI_DAUDIOFCTL); reg_val &= ~(0x1<<2); sunxi_smc_writel(reg_val, sunxi_daudio.regs + SUNXI_DAUDIOFCTL); } else { reg_val = sunxi_smc_readl(sunxi_daudio.regs + SUNXI_DAUDIOFCTL); reg_val |= SUNXI_DAUDIOFCTL_TXIM; sunxi_smc_writel(reg_val, sunxi_daudio.regs + SUNXI_DAUDIOFCTL); } /* play or record */ if(substream->stream == SNDRV_PCM_STREAM_PLAYBACK) dma_data = &sunxi_daudio_pcm_stereo_out; else dma_data = &sunxi_daudio_pcm_stereo_in; snd_soc_dai_set_dma_data(rtd->cpu_dai, substream, dma_data); return 0; }
static int s3c2412_i2s_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *socdai) { struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_dai_link *dai = rtd->dai; struct s3c_i2sv2_info *i2s = to_info(dai->cpu_dai); struct s3c_dma_params *dma_data; u32 iismod; pr_debug("Entered %s\n", __func__); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) dma_data = i2s->dma_playback; else dma_data = i2s->dma_capture; snd_soc_dai_set_dma_data(dai->cpu_dai, substream, dma_data); /* Working copies of register */ iismod = readl(i2s->regs + S3C2412_IISMOD); pr_debug("%s: r: IISMOD: %x\n", __func__, iismod); #if defined(CONFIG_CPU_S3C2412) || defined(CONFIG_CPU_S3C2413) switch (params_format(params)) { case SNDRV_PCM_FORMAT_S8: iismod |= S3C2412_IISMOD_8BIT; break; case SNDRV_PCM_FORMAT_S16_LE: iismod &= ~S3C2412_IISMOD_8BIT; break; } #endif #ifdef CONFIG_PLAT_S3C64XX iismod &= ~(S3C64XX_IISMOD_BLC_MASK | S3C2412_IISMOD_BCLK_MASK); /* Sample size */ switch (params_format(params)) { case SNDRV_PCM_FORMAT_S8: /* 8 bit sample, 16fs BCLK */ iismod |= (S3C64XX_IISMOD_BLC_8BIT | S3C2412_IISMOD_BCLK_16FS); break; case SNDRV_PCM_FORMAT_S16_LE: /* 16 bit sample, 32fs BCLK */ break; case SNDRV_PCM_FORMAT_S24_LE: /* 24 bit sample, 48fs BCLK */ iismod |= (S3C64XX_IISMOD_BLC_24BIT | S3C2412_IISMOD_BCLK_48FS); break; } #endif writel(iismod, i2s->regs + S3C2412_IISMOD); pr_debug("%s: w: IISMOD: %x\n", __func__, iismod); return 0; }
static int pxa2xx_ac97_mic_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *cpu_dai) { if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) return -ENODEV; snd_soc_dai_set_dma_data(cpu_dai, substream, &pxa2xx_ac97_pcm_mic_mono_in); return 0; }
static int spdif_in_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *cpu_dai) { struct spdif_in_dev *host = snd_soc_dai_get_drvdata(cpu_dai); if (substream->stream != SNDRV_PCM_STREAM_CAPTURE) return -EINVAL; snd_soc_dai_set_dma_data(cpu_dai, substream, (void *)&host->dma_params); return 0; }
static void spdif_in_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct spdif_in_dev *host = snd_soc_dai_get_drvdata(dai); if (substream->stream != SNDRV_PCM_STREAM_CAPTURE) return; writel(0x0, host->io_base + SPDIF_IN_IRQ_MASK); snd_soc_dai_set_dma_data(dai, substream, NULL); }
static void spdif_out_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct spdif_out_dev *host = snd_soc_dai_get_drvdata(dai); if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) return; clk_disable(host->clk); host->running = false; snd_soc_dai_set_dma_data(dai, substream, NULL); }
static int stm32_sai_set_config(struct snd_soc_dai *cpu_dai, struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai); int cr1, cr1_mask, ret; int fth = STM_SAI_FIFO_TH_HALF; /* FIFO config */ regmap_update_bits(sai->regmap, STM_SAI_CR2_REGX, SAI_XCR2_FFLUSH | SAI_XCR2_FTH_MASK, SAI_XCR2_FFLUSH | SAI_XCR2_FTH_SET(fth)); /* Mode, data format and channel config */ cr1 = SAI_XCR1_PRTCFG_SET(SAI_FREE_PROTOCOL); switch (params_format(params)) { case SNDRV_PCM_FORMAT_S8: cr1 |= SAI_XCR1_DS_SET(SAI_DATASIZE_8); break; case SNDRV_PCM_FORMAT_S16_LE: cr1 |= SAI_XCR1_DS_SET(SAI_DATASIZE_16); break; case SNDRV_PCM_FORMAT_S32_LE: cr1 |= SAI_XCR1_DS_SET(SAI_DATASIZE_32); break; default: dev_err(cpu_dai->dev, "Data format not supported"); return -EINVAL; } cr1_mask = SAI_XCR1_DS_MASK | SAI_XCR1_PRTCFG_MASK; cr1_mask |= SAI_XCR1_RX_TX; if (STM_SAI_IS_CAPTURE(sai)) cr1 |= SAI_XCR1_RX_TX; cr1_mask |= SAI_XCR1_MONO; if ((sai->slots == 2) && (params_channels(params) == 1)) cr1 |= SAI_XCR1_MONO; ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, cr1_mask, cr1); if (ret < 0) { dev_err(cpu_dai->dev, "Failed to update CR1 register\n"); return ret; } /* DMA config */ sai->dma_params.maxburst = STM_SAI_FIFO_SIZE * fth / sizeof(u32); snd_soc_dai_set_dma_data(cpu_dai, substream, (void *)&sai->dma_params); return 0; }
static int pxa2xx_ac97_aux_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *cpu_dai) { struct snd_dmaengine_dai_dma_data *dma_data; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) dma_data = &pxa2xx_ac97_pcm_aux_mono_out; else dma_data = &pxa2xx_ac97_pcm_aux_mono_in; snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data); return 0; }
static void pxa_ssp_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *cpu_dai) { struct ssp_priv *priv = snd_soc_dai_get_drvdata(cpu_dai); struct ssp_device *ssp = priv->ssp; if (!cpu_dai->active) { pxa_ssp_disable(ssp); clk_disable(ssp->clk); } kfree(snd_soc_dai_get_dma_data(cpu_dai, substream)); snd_soc_dai_set_dma_data(cpu_dai, substream, NULL); }
static int jz4740_i2s_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct jz4740_i2s *i2s = snd_soc_dai_get_drvdata(dai); enum jz4740_dma_width dma_width; struct jz4740_pcm_config *pcm_config; unsigned int sample_size; uint32_t ctrl; ctrl = jz4740_i2s_read(i2s, JZ_REG_AIC_CTRL); switch (params_format(params)) { case SNDRV_PCM_FORMAT_S8: sample_size = 0; dma_width = JZ4740_DMA_WIDTH_8BIT; break; case SNDRV_PCM_FORMAT_S16: sample_size = 1; dma_width = JZ4740_DMA_WIDTH_16BIT; break; default: return -EINVAL; } if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { ctrl &= ~JZ_AIC_CTRL_OUTPUT_SAMPLE_SIZE_MASK; ctrl |= sample_size << JZ_AIC_CTRL_OUTPUT_SAMPLE_SIZE_OFFSET; if (params_channels(params) == 1) ctrl |= JZ_AIC_CTRL_MONO_TO_STEREO; else ctrl &= ~JZ_AIC_CTRL_MONO_TO_STEREO; pcm_config = &i2s->pcm_config_playback; pcm_config->dma_config.dst_width = dma_width; } else { ctrl &= ~JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_MASK; ctrl |= sample_size << JZ_AIC_CTRL_INPUT_SAMPLE_SIZE_OFFSET; pcm_config = &i2s->pcm_config_capture; pcm_config->dma_config.src_width = dma_width; } jz4740_i2s_write(i2s, JZ_REG_AIC_CTRL, ctrl); snd_soc_dai_set_dma_data(dai, substream, pcm_config); return 0; }
static int pxa2xx_ac97_hw_aux_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *cpu_dai) { struct pxa2xx_pcm_dma_params *dma_data; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) dma_data = &pxa2xx_ac97_pcm_aux_mono_out; else dma_data = &pxa2xx_ac97_pcm_aux_mono_in; snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data); return 0; }
static int sun6i_i2s_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct snd_soc_pcm_runtime *rtd = substream->private_data; struct sun6i_dma_params *dma_data; /* play or record */ if(substream->stream == SNDRV_PCM_STREAM_PLAYBACK) dma_data = &sun6i_i2s_pcm_stereo_out; else dma_data = &sun6i_i2s_pcm_stereo_in; snd_soc_dai_set_dma_data(rtd->cpu_dai, substream, dma_data); return 0; }