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

static int sst_byt_pcm_open(struct snd_pcm_substream *substream){    struct snd_soc_pcm_runtime *rtd = substream->private_data;    struct sst_byt_priv_data *pdata =        snd_soc_platform_get_drvdata(rtd->platform);    struct sst_byt_pcm_data *pcm_data = &pdata->pcm[substream->stream];    struct sst_byt *byt = pdata->byt;    dev_dbg(rtd->dev, "PCM: open/n");    mutex_lock(&pcm_data->mutex);    pcm_data->substream = substream;    snd_soc_set_runtime_hwparams(substream, &sst_byt_pcm_hardware);    pcm_data->stream = sst_byt_stream_new(byt, substream->stream + 1,                                          byt_notify_pointer, pcm_data);    if (pcm_data->stream == NULL) {        dev_err(rtd->dev, "failed to create stream/n");        mutex_unlock(&pcm_data->mutex);        return -EINVAL;    }    mutex_unlock(&pcm_data->mutex);    return 0;}

static int hi3630_srcup_normal_new(struct snd_soc_pcm_runtime *rtd){	struct snd_card *card = rtd->card->snd_card;	struct snd_pcm  *pcm  = rtd->pcm;	struct hi3630_srcup_data *pdata =		(struct hi3630_srcup_data *)snd_soc_platform_get_drvdata(rtd->platform);	int ret = 0;	BUG_ON(NULL == card);	BUG_ON(NULL == pcm);	BUG_ON(NULL == pdata);	if (!card->dev->dma_mask)		card->dev->dma_mask = &hi3630_pcm_dmamask;	if (!card->dev->coherent_dma_mask)		card->dev->coherent_dma_mask = DMA_BIT_MASK(32);	if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {		ret = hi3630_pcm_preallocate_dma_buffer(pcm,			SNDRV_PCM_STREAM_PLAYBACK);		if (ret) {			loge("preallocate dma buffer error, error No. = %d/n", ret);			return ret;		}	}	return ret;}

static snd_pcm_uframes_t lpass_platform_pcmops_pointer(		struct snd_pcm_substream *substream){	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;	struct lpass_data *drvdata =			snd_soc_platform_get_drvdata(soc_runtime->platform);	unsigned int base_addr, curr_addr;	int ret;	ret = regmap_read(drvdata->lpaif_map,			LPAIF_RDMABASE_REG(LPAIF_RDMA_CHAN_MI2S), &base_addr);	if (ret) {		dev_err(soc_runtime->dev, "%s() error reading from rdmabase reg: %d/n",				__func__, ret);		return ret;	}	ret = regmap_read(drvdata->lpaif_map,			LPAIF_RDMACURR_REG(LPAIF_RDMA_CHAN_MI2S), &curr_addr);	if (ret) {		dev_err(soc_runtime->dev, "%s() error reading from rdmacurr reg: %d/n",				__func__, ret);		return ret;	}	return bytes_to_frames(substream->runtime, curr_addr - base_addr);}

static int hsw_pcm_open(struct snd_pcm_substream *substream){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct hsw_priv_data *pdata =		snd_soc_platform_get_drvdata(rtd->platform);	struct hsw_pcm_data *pcm_data;	struct sst_hsw *hsw = pdata->hsw;	pcm_data = &pdata->pcm[rtd->cpu_dai->id];	mutex_lock(&pcm_data->mutex);	snd_soc_pcm_set_drvdata(rtd, pcm_data);	pcm_data->substream = substream;	snd_soc_set_runtime_hwparams(substream, &hsw_pcm_hardware);	pcm_data->stream = sst_hsw_stream_new(hsw, rtd->cpu_dai->id,		hsw_notify_pointer, pcm_data);	if (pcm_data->stream == NULL) {		dev_err(rtd->dev, "error: failed to create stream/n");		mutex_unlock(&pcm_data->mutex);		return -EINVAL;	}	/* Set previous saved volume */	sst_hsw_stream_set_volume(hsw, pcm_data->stream, 0,			0, pcm_data->volume[0]);	sst_hsw_stream_set_volume(hsw, pcm_data->stream, 0,			1, pcm_data->volume[1]);	mutex_unlock(&pcm_data->mutex);	return 0;}

static int hsw_pcm_close(struct snd_pcm_substream *substream){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct hsw_priv_data *pdata =		snd_soc_platform_get_drvdata(rtd->platform);	struct hsw_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);	struct sst_hsw *hsw = pdata->hsw;	int ret;	mutex_lock(&pcm_data->mutex);	ret = sst_hsw_stream_reset(hsw, pcm_data->stream);	if (ret < 0) {		dev_dbg(rtd->dev, "error: reset stream failed %d/n", ret);		goto out;	}	ret = sst_hsw_stream_free(hsw, pcm_data->stream);	if (ret < 0) {		dev_dbg(rtd->dev, "error: free stream failed %d/n", ret);		goto out;	}	pcm_data->stream = NULL;out:	mutex_unlock(&pcm_data->mutex);	return ret;}

static int hsw_stream_volume_get(struct snd_kcontrol *kcontrol,				struct snd_ctl_elem_value *ucontrol){	struct snd_soc_platform *platform = snd_kcontrol_chip(kcontrol);	struct soc_mixer_control *mc =		(struct soc_mixer_control *)kcontrol->private_value;	struct hsw_priv_data *pdata =		snd_soc_platform_get_drvdata(platform);	struct hsw_pcm_data *pcm_data = &pdata->pcm[mc->reg];	struct sst_hsw *hsw = pdata->hsw;	u32 volume;	mutex_lock(&pcm_data->mutex);	if (!pcm_data->stream) {		ucontrol->value.integer.value[0] =			hsw_ipc_to_mixer(pcm_data->volume[0]);		ucontrol->value.integer.value[1] =			hsw_ipc_to_mixer(pcm_data->volume[1]);		mutex_unlock(&pcm_data->mutex);		return 0;	}	sst_hsw_stream_get_volume(hsw, pcm_data->stream, 0, 0, &volume);	ucontrol->value.integer.value[0] = hsw_ipc_to_mixer(volume);	sst_hsw_stream_get_volume(hsw, pcm_data->stream, 0, 1, &volume);	ucontrol->value.integer.value[1] = hsw_ipc_to_mixer(volume);	mutex_unlock(&pcm_data->mutex);	return 0;}

static int hsw_pcm_trigger(struct snd_pcm_substream *substream, int cmd){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct hsw_priv_data *pdata =		snd_soc_platform_get_drvdata(rtd->platform);	struct hsw_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);	struct sst_hsw *hsw = pdata->hsw;	switch (cmd) {	case SNDRV_PCM_TRIGGER_START:	case SNDRV_PCM_TRIGGER_RESUME:	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:		sst_hsw_stream_resume(hsw, pcm_data->stream, 0);		break;	case SNDRV_PCM_TRIGGER_STOP:	case SNDRV_PCM_TRIGGER_SUSPEND:	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:		sst_hsw_stream_pause(hsw, pcm_data->stream, 0);		break;	default:		break;	}	return 0;}

static int sst_soc_probe(struct snd_soc_platform *platform){	struct sst_data *ctx = snd_soc_platform_get_drvdata(platform);	struct soft_platform_id spid;	int ret = 0;	memcpy(&spid, ctx->pdata->spid, sizeof(spid));	pr_debug("Enter:%s/n", __func__);	if (INTEL_MID_BOARD(1, PHONE, CLVTP) ||	    INTEL_MID_BOARD(1, TABLET, CLVT) ||	    INTEL_MID_BOARD(1, TABLET, BYT))		return sst_platform_clv_init(platform);	if (INTEL_MID_BOARD(1, PHONE, MRFL) ||			INTEL_MID_BOARD(1, TABLET, MRFL) ||			INTEL_MID_BOARD(1, PHONE, MOFD) ||			INTEL_MID_BOARD(1, TABLET, MOFD)) {#if IS_BUILTIN(CONFIG_SST_MRFLD_DPCM)		ret = sst_dsp_init_v2_dpcm(platform);#else		ret = sst_dsp_init(platform);#endif		if (ret)			return ret;		ret = snd_soc_register_effect(platform->card, &effects_ops);	}	if (INTEL_MID_BOARD(1, TABLET, CHT)) {		ret = sst_dsp_init(platform);		if (ret)			pr_err("Dsp init failed: %d/n", ret);	}	return ret;}

static int sst_byt_pcm_trigger(struct snd_pcm_substream *substream, int cmd){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct sst_byt_priv_data *pdata =		snd_soc_platform_get_drvdata(rtd->platform);	struct sst_byt_pcm_data *pcm_data = snd_soc_pcm_get_drvdata(rtd);	struct sst_byt *byt = pdata->byt;	dev_dbg(rtd->dev, "PCM: trigger %d/n", cmd);	switch (cmd) {	case SNDRV_PCM_TRIGGER_START:		sst_byt_stream_start(byt, pcm_data->stream);		break;	case SNDRV_PCM_TRIGGER_RESUME:	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:		sst_byt_stream_resume(byt, pcm_data->stream);		break;	case SNDRV_PCM_TRIGGER_STOP:		sst_byt_stream_stop(byt, pcm_data->stream);		break;	case SNDRV_PCM_TRIGGER_SUSPEND:	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:		sst_byt_stream_pause(byt, pcm_data->stream);		break;	default:		break;	}	return 0;}

static int lpe_mixer_headset_set(struct snd_kcontrol *kcontrol,                                 struct snd_ctl_elem_value *ucontrol){    int mixer_input_stream;    struct snd_soc_platform *platform = snd_kcontrol_chip(kcontrol);    struct sst_data *sst = snd_soc_platform_get_drvdata(platform);    switch (ucontrol->value.integer.value[0]) {    case 0:        pr_debug("input is None/n");        mixer_input_stream = SST_STREAM_DEVICE_HS                             | SST_INPUT_STREAM_NONE;        break;    case 1:        pr_debug("input is PCM stream/n");        mixer_input_stream = SST_STREAM_DEVICE_HS                             | SST_INPUT_STREAM_PCM;        break;    case 2:        pr_debug("input is Compress  stream/n");        mixer_input_stream = SST_STREAM_DEVICE_HS                             | SST_INPUT_STREAM_COMPRESS;        break;    case 3:        pr_debug("input is Mixed stream/n");        mixer_input_stream = SST_STREAM_DEVICE_HS                             | SST_INPUT_STREAM_MIXED;        break;    default:        pr_err("Invalid Input:%ld/n", ucontrol->value.integer.value[0]);        return -EINVAL;    }    sst->lpe_mixer_input_hs  = ucontrol->value.integer.value[0];    return sst_set_mixer_param(mixer_input_stream);}

static int ath79_pcm_close(struct snd_pcm_substream *ss){	struct snd_soc_pcm_runtime *runtime = ss->private_data;	struct snd_soc_platform *platform = runtime->platform;	struct ath79_pcm_pltfm_priv *prdata = snd_soc_platform_get_drvdata(platform);	struct ath79_pcm_rt_priv *rtpriv;	if (!prdata)		return 0;	if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) {		prdata->playback = NULL;	} else {		prdata->capture = NULL;	}	if (!prdata->playback && !prdata->capture) {		free_irq(ATH79_MISC_IRQ(7), prdata);		kfree(prdata);		snd_soc_platform_set_drvdata(platform, NULL);	}	rtpriv = ss->runtime->private_data;	kfree(rtpriv);	return 0;}

/* TODO: we have to use the shift value atm to represent register * id due to current HAL ID MACROS not being unique. */static int put_mixer(struct snd_kcontrol *kcontrol,	struct snd_ctl_elem_value *ucontrol){	struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);	struct snd_soc_dapm_widget *widget = wlist->widgets[0];	struct snd_soc_platform *platform = widget->platform;	struct omap_abe *abe = snd_soc_platform_get_drvdata(platform);	struct soc_mixer_control *mc =		(struct soc_mixer_control *)kcontrol->private_value;	abe_dsp_pm_get(abe);	if (ucontrol->value.integer.value[0]) {		abe->opp.widget[mc->reg] |= ucontrol->value.integer.value[0]<<mc->shift;		snd_soc_dapm_mixer_update_power(widget, kcontrol, 1);		omap_aess_enable_gain(abe->aess, mc->reg);	} else {		abe->opp.widget[mc->reg] &= ~(0x1<<mc->shift);		snd_soc_dapm_mixer_update_power(widget, kcontrol, 0);		omap_aess_disable_gain(abe->aess, mc->reg);	}	pm_runtime_put_sync(abe->dev);	return 1;}

static snd_pcm_uframes_t mtk_afe_pcm_pointer			 (struct snd_pcm_substream *substream){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);	struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];	const struct mtk_base_memif_data *memif_data = memif->data;	struct regmap *regmap = afe->regmap;	struct device *dev = afe->dev;	int reg_ofs_base = memif_data->reg_ofs_base;	int reg_ofs_cur = memif_data->reg_ofs_cur;	unsigned int hw_ptr = 0, hw_base = 0;	int ret, pcm_ptr_bytes;	ret = regmap_read(regmap, reg_ofs_cur, &hw_ptr);	if (ret || hw_ptr == 0) {		dev_err(dev, "%s hw_ptr err/n", __func__);		pcm_ptr_bytes = 0;		goto POINTER_RETURN_FRAMES;	}	ret = regmap_read(regmap, reg_ofs_base, &hw_base);	if (ret || hw_base == 0) {		dev_err(dev, "%s hw_ptr err/n", __func__);		pcm_ptr_bytes = 0;		goto POINTER_RETURN_FRAMES;	}	pcm_ptr_bytes = hw_ptr - hw_base;POINTER_RETURN_FRAMES:	return bytes_to_frames(substream->runtime, pcm_ptr_bytes);}

static int ul_mux_get_route(struct snd_kcontrol *kcontrol,	struct snd_ctl_elem_value *ucontrol){	struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);	struct snd_soc_dapm_widget *widget = wlist->widgets[0];	struct snd_soc_platform *platform = widget->platform;	struct omap_abe *abe = snd_soc_platform_get_drvdata(platform);	struct soc_enum *e =		(struct soc_enum *)kcontrol->private_value;	int reg = e->reg - OMAP_ABE_MUX(0), i, rval = 0;	/* TODO: remove the gap */	if (reg < 8) {		/* 0  .. 9   = MM_UL */		rval = abe->mixer.route_ul[reg];	} else if (reg < 12) {		/* 10 .. 11  = MM_UL2 */		/* 12 .. 13  = VX_UL */		rval = abe->mixer.route_ul[reg + 2];	}	for (i = 0; i < ARRAY_SIZE(router); i++) {		if (router[i] == rval) {			ucontrol->value.integer.value[0] = i;			return 0;		}	}	return 1;}

/* set optimum DL1 output path gain for ABE -> McPDM -> twl6040 */static int omap_abe_set_pdm_dl1_gains(struct snd_soc_dapm_context *dapm){	int gain_dB = 0, gain;	struct snd_soc_card *card = dapm->card;	struct omap_abe_data *abe_data = snd_soc_card_get_drvdata(card);	struct snd_soc_codec *codec = abe_data->twl6040_codec;	struct snd_soc_platform *platform = abe_data->abe_platform;	struct omap_abe *abe = snd_soc_platform_get_drvdata(platform);	if (codec) {#if !defined(CONFIG_SND_OMAP_SOC_ABE_DL2)		gain_dB = twl6040_get_dl2_gain(codec);#endif		if (!gain_dB)			gain_dB = twl6040_get_dl1_gain(codec);	}	switch (gain_dB) {	case -8:		gain = GAIN_M8dB;		break;	case -7:		gain = GAIN_M7dB;		break;	case -1:		gain = GAIN_M1dB;		break;	default:		gain = GAIN_0dB;		break;	}	omap_aess_write_gain(abe->aess, OMAP_AESS_GAIN_DL1_LEFT, gain);	omap_aess_write_gain(abe->aess, OMAP_AESS_GAIN_DL1_RIGHT, gain);	return 0;}

static int mt_pcm_mrgrx_close(struct snd_pcm_substream *substream){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct mt_pcm_mrgrx_priv *priv = snd_soc_platform_get_drvdata(rtd->platform);	pr_debug("%s/n", __func__);	mtk_wcn_cmb_stub_audio_ctrl((CMB_STUB_AIF_X) CMB_STUB_AIF_0);	mt_afe_disable_memory_path(MT_AFE_DIGITAL_BLOCK_MRG_I2S_OUT);	if (mt_afe_get_memory_path_state(MT_AFE_DIGITAL_BLOCK_MRG_I2S_OUT) == false)		mt_afe_disable_merge_i2s();	mt_afe_disable_memory_path(MT_AFE_DIGITAL_BLOCK_I2S_OUT_DAC);	if (mt_afe_get_memory_path_state(MT_AFE_DIGITAL_BLOCK_I2S_OUT_DAC) == false)		mt_afe_disable_i2s_dac();	mt_afe_set_connection(INTER_DISCONNECT, INTER_CONN_I15, INTER_CONN_O13);	mt_afe_set_connection(INTER_DISCONNECT, INTER_CONN_I16, INTER_CONN_O14);	mt_afe_set_connection(INTER_DISCONNECT, INTER_CONN_I10, INTER_CONN_O03);	mt_afe_set_connection(INTER_DISCONNECT, INTER_CONN_I11, INTER_CONN_O04);	mt_afe_enable_afe(false);	mt_afe_dac_clk_off();	mt_afe_main_clk_off();	priv->prepare_done = false;	return 0;}

static int msm_compr_volume_put(struct snd_kcontrol *kcontrol,				struct snd_ctl_elem_value *ucontrol){	struct snd_soc_platform *platform = snd_kcontrol_chip(kcontrol);	unsigned long fe_id = kcontrol->private_value;	struct msm_compr_pdata *pdata = (struct msm_compr_pdata *)			snd_soc_platform_get_drvdata(platform);	struct snd_compr_stream *cstream = NULL;	uint32_t *volume = NULL;	if (fe_id >= MSM_FRONTEND_DAI_MAX) {		pr_err("%s Received out of bounds fe_id %lu/n",			__func__, fe_id);		return -EINVAL;	}	cstream = pdata->cstream[fe_id];	volume = pdata->volume[fe_id];	volume[0] = ucontrol->value.integer.value[0];	volume[1] = ucontrol->value.integer.value[1];	pr_debug("%s: fe_id %lu left_vol %d right_vol %d/n",		 __func__, fe_id, volume[0], volume[1]);	if (cstream)		msm_compr_set_volume(cstream, volume[0], volume[1]);	return 0;}

static int aess_close(struct snd_pcm_substream *substream){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct snd_soc_platform *platform = rtd->platform;	struct omap_abe *abe = snd_soc_platform_get_drvdata(platform);	struct snd_soc_dai *dai = rtd->cpu_dai;	dev_dbg(dai->dev, "%s: %s/n", __func__, dai->name);	mutex_lock(&abe->mutex);	if (!--abe->active) {		omap_aess_disable_irq(abe->aess);		abe_pm_save_context(abe);		omap_abe_pm_shutdown(platform);	} else {		/* Only scale OPP level		 * if ABE is still active */		abe_opp_recalc_level(abe);	}	omap_abe_pm_runtime_put_sync(abe);	mutex_unlock(&abe->mutex);	return 0;}

/* * cpe_get_private_data: obtain ASoC platform driver private data * @substream: ASoC substream for which private data to be obtained */static struct cpe_priv *cpe_get_private_data(	struct snd_pcm_substream *substream){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct snd_soc_platform *platform = rtd->platform;	return snd_soc_platform_get_drvdata(platform);}

static int lpe_mixer_headset_get(struct snd_kcontrol *kcontrol,                                 struct snd_ctl_elem_value *ucontrol){    struct snd_soc_platform *platform = snd_kcontrol_chip(kcontrol);    struct sst_data *sst = snd_soc_platform_get_drvdata(platform);    ucontrol->value.integer.value[0] = sst->lpe_mixer_input_hs;    return 0;}

int sst_platform_clv_init(struct snd_soc_platform *platform){    struct sst_data *ctx = snd_soc_platform_get_drvdata(platform);    ctx->lpe_mixer_input_hs = 0;    ctx->lpe_mixer_input_ihf = 0;    snd_soc_add_platform_controls(platform, sst_controls_clv,                                  ARRAY_SIZE(sst_controls_clv));    return 0;}

static int abe_get_equalizer(struct snd_kcontrol *kcontrol,			struct snd_ctl_elem_value *ucontrol){	struct snd_soc_platform *platform = snd_kcontrol_chip(kcontrol);	struct omap_abe *abe = snd_soc_platform_get_drvdata(platform);	struct soc_enum *eqc = (struct soc_enum *)kcontrol->private_value;	ucontrol->value.integer.value[0] = abe->equ.profile[eqc->reg];	return 0;}

int abe_mixer_write(struct snd_soc_platform *platform, unsigned int reg,		unsigned int val){	struct omap_abe *abe = snd_soc_platform_get_drvdata(platform);	BUG_ON(reg > OMAP_ABE_NUM_DAPM_REG);	abe->opp.widget[reg] = val;	dev_dbg(platform->dev, "write R%d (Ox%x) = 0x%x/n", reg, reg, val);	return 0;}

/* TODO: map IO directly into ABE memories */unsigned int abe_mixer_read(struct snd_soc_platform *platform,		unsigned int reg){	struct omap_abe *abe = snd_soc_platform_get_drvdata(platform);	BUG_ON(reg > OMAP_ABE_NUM_DAPM_REG);	dev_dbg(platform->dev, "read R%d (Ox%x) = 0x%x/n",			reg, reg, abe->opp.widget[reg]);	return abe->opp.widget[reg];}

static int aess_hw_params(struct snd_pcm_substream *substream,	struct snd_pcm_hw_params *params){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct snd_pcm_runtime *runtime = substream->runtime;	struct snd_soc_platform *platform = rtd->platform;	struct omap_abe *abe = snd_soc_platform_get_drvdata(platform);	struct snd_soc_dai *dai = rtd->cpu_dai;	struct omap_aess_data_format format;	size_t period_size;	u32 dst, param[2];	int ret = 0;	mutex_lock(&abe->mutex);	dev_dbg(dai->dev, "%s: %s/n", __func__, dai->name);	if (dai->id != OMAP_ABE_FRONTEND_DAI_LP_MEDIA)		goto out;	format.f = params_rate(params);	if (params_format(params) == SNDRV_PCM_FORMAT_S32_LE)		format.samp_format = STEREO_MSB;	else		format.samp_format = STEREO_16_16;	period_size = params_period_bytes(params);	param[0] = (u32)substream;	param[1] = (u32)abe;	/* Adding ping pong buffer subroutine */	omap_aess_plug_subroutine(abe->aess, &abe->aess->seq.irq_pingpong_player_id,				(abe_subroutine2) abe_irq_pingpong_subroutine,				2, param);	/* Connect a Ping-Pong cache-flush protocol to MM_DL port */	omap_aess_connect_irq_ping_pong_port(abe->aess, OMAP_ABE_MM_DL_PORT, &format,				abe->aess->seq.irq_pingpong_player_id,				period_size, &dst,				PING_PONG_WITH_MCU_IRQ);	/* Memory mapping for hw params */	runtime->dma_area  = abe->io_base[0] + dst;	runtime->dma_addr  = 0;	runtime->dma_bytes = period_size * 4;	/* Need to set the first buffer in order to get interrupt */	omap_aess_set_ping_pong_buffer(abe->aess, OMAP_ABE_MM_DL_PORT, period_size);	abe->mmap.first_irq = 1;out:	mutex_unlock(&abe->mutex);	return ret;}

static int mtk_afe_pcm_new(struct snd_soc_pcm_runtime *rtd){	size_t size;	struct snd_card *card = rtd->card->snd_card;	struct snd_pcm *pcm = rtd->pcm;	struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);	size = afe->mtk_afe_hardware->buffer_bytes_max;	return snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,						     card->dev, size, size);}

static int abe_get_mono_mixer(struct snd_kcontrol *kcontrol,	struct snd_ctl_elem_value *ucontrol){	struct snd_soc_platform *platform = snd_kcontrol_chip(kcontrol);	struct omap_abe *abe = snd_soc_platform_get_drvdata(platform);	struct soc_mixer_control *mc =		(struct soc_mixer_control *)kcontrol->private_value;	int id = mc->shift - MIX_DL1_MONO;	ucontrol->value.integer.value[0] = abe->mixer.mono[id];	return 0;}

static int aess_open(struct snd_pcm_substream *substream){	struct snd_soc_pcm_runtime *rtd = substream->private_data;	struct snd_soc_platform *platform = rtd->platform;	struct omap_abe *abe = snd_soc_platform_get_drvdata(platform);	struct snd_soc_dai *dai = rtd->cpu_dai;	int ret = 0;	mutex_lock(&abe->mutex);	dev_dbg(dai->dev, "%s: %s/n", __func__, dai->name);	switch (dai->id) {	case OMAP_ABE_FRONTEND_DAI_MODEM:		break;	case OMAP_ABE_FRONTEND_DAI_LP_MEDIA:		snd_soc_set_runtime_hwparams(substream, &omap_abe_hardware);		ret = snd_pcm_hw_constraint_step(substream->runtime, 0,					 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 1024);		break;	default:		/*		 * Period size must be aligned with the Audio Engine		 * processing loop which is 250 us long		 */		ret = snd_pcm_hw_rule_add(substream->runtime, 0,					SNDRV_PCM_HW_PARAM_PERIOD_SIZE,					omap_abe_hwrule_period_step,					NULL,					SNDRV_PCM_HW_PARAM_PERIOD_SIZE, -1);		break;	}	if (ret < 0) {		dev_err(abe->dev, "failed to set period constraints for DAI %d/n",			dai->id);		goto out;	}	omap_abe_pm_runtime_get_sync(abe);	if (!abe->active++) {		abe->opp.level = 0;		ret = abe_pm_restore_context(abe);		if (ret)			goto out;		omap_aess_wakeup(abe->aess);	}out:	mutex_unlock(&abe->mutex);	return ret;}

static snd_pcm_uframes_t sst_byt_pcm_pointer(struct snd_pcm_substream *substream){    struct snd_soc_pcm_runtime *rtd = substream->private_data;    struct snd_pcm_runtime *runtime = substream->runtime;    struct sst_byt_priv_data *pdata =        snd_soc_platform_get_drvdata(rtd->platform);    struct sst_byt_pcm_data *pcm_data = &pdata->pcm[substream->stream];    dev_dbg(rtd->dev, "PCM: DMA pointer %u bytes/n", pcm_data->hw_ptr);    return bytes_to_frames(runtime, pcm_data->hw_ptr);}

void omap_abe_dc_set_hf_offset(struct snd_soc_platform *platform,	int left, int right){	struct omap_abe *abe = snd_soc_platform_get_drvdata(platform);	if (left >= 8)		left -= 16;	abe->dc_offset.hfl = OMAP_ABE_HF_DC_OFFSET_STEP * left;	if (right >= 8)		right -= 16;	abe->dc_offset.hfr = OMAP_ABE_HF_DC_OFFSET_STEP * right;}