[deliverable/linux.git] / sound / soc / mediatek / common / mtk-afe-fe-dai.c

/*
 * mtk-afe-fe-dais.c  --  Mediatek afe fe dai operator
 *
 * Copyright (c) 2016 MediaTek Inc.
 * Author: Garlic Tseng <garlic.tseng@mediatek.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/module.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include <sound/soc.h>
#include "mtk-afe-fe-dai.h"
#include "mtk-base-afe.h"

#define AFE_BASE_END_OFFSET 8

static int mtk_regmap_update_bits(struct regmap *map, int reg,
			   unsigned int mask,
			   unsigned int val)
{
	if (reg < 0)
		return 0;
	return regmap_update_bits(map, reg, mask, val);
}

static int mtk_regmap_write(struct regmap *map, int reg, unsigned int val)
{
	if (reg < 0)
		return 0;
	return regmap_write(map, reg, val);
}

int mtk_afe_fe_startup(struct snd_pcm_substream *substream,
		       struct snd_soc_dai *dai)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
	struct snd_pcm_runtime *runtime = substream->runtime;
	int memif_num = rtd->cpu_dai->id;
	struct mtk_base_afe_memif *memif = &afe->memif[memif_num];
	const struct snd_pcm_hardware *mtk_afe_hardware = afe->mtk_afe_hardware;
	int ret;

	memif->substream = substream;

	snd_pcm_hw_constraint_step(substream->runtime, 0,
				   SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 16);
	/* enable agent */
	mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg,
			       1 << memif->data->agent_disable_shift,
			       0 << memif->data->agent_disable_shift);

	snd_soc_set_runtime_hwparams(substream, mtk_afe_hardware);

	/*
	 * Capture cannot use ping-pong buffer since hw_ptr at IRQ may be
	 * smaller than period_size due to AFE's internal buffer.
	 * This easily leads to overrun when avail_min is period_size.
	 * One more period can hold the possible unread buffer.
	 */
	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
		int periods_max = mtk_afe_hardware->periods_max;

		ret = snd_pcm_hw_constraint_minmax(runtime,
						   SNDRV_PCM_HW_PARAM_PERIODS,
						   3, periods_max);
		if (ret < 0) {
			dev_err(afe->dev, "hw_constraint_minmax failed\n");
			return ret;
		}
	}

	ret = snd_pcm_hw_constraint_integer(runtime,
					    SNDRV_PCM_HW_PARAM_PERIODS);
	if (ret < 0)
		dev_err(afe->dev, "snd_pcm_hw_constraint_integer failed\n");

	/* dynamic allocate irq to memif */
	if (memif->irq_usage < 0) {
		int irq_id = mtk_dynamic_irq_acquire(afe);

		if (irq_id != afe->irqs_size) {
			/* link */
			memif->irq_usage = irq_id;
		} else {
			dev_err(afe->dev, "%s() error: no more asys irq\n",
				__func__);
			ret = -EBUSY;
		}
	}
	return ret;
}
EXPORT_SYMBOL_GPL(mtk_afe_fe_startup);

void mtk_afe_fe_shutdown(struct snd_pcm_substream *substream,
			 struct snd_soc_dai *dai)
{
	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];
	int irq_id;

	irq_id = memif->irq_usage;

	mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg,
			       1 << memif->data->agent_disable_shift,
			       1 << memif->data->agent_disable_shift);

	if (!memif->const_irq) {
		mtk_dynamic_irq_release(afe, irq_id);
		memif->irq_usage = -1;
		memif->substream = NULL;
	}
}
EXPORT_SYMBOL_GPL(mtk_afe_fe_shutdown);

int mtk_afe_fe_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 mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
	struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
	int msb_at_bit33 = 0;
	int ret, fs = 0;

	ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
	if (ret < 0)
		return ret;

	msb_at_bit33 = upper_32_bits(substream->runtime->dma_addr) ? 1 : 0;
	memif->phys_buf_addr = lower_32_bits(substream->runtime->dma_addr);
	memif->buffer_size = substream->runtime->dma_bytes;

	/* start */
	mtk_regmap_write(afe->regmap, memif->data->reg_ofs_base,
			 memif->phys_buf_addr);
	/* end */
	mtk_regmap_write(afe->regmap,
			 memif->data->reg_ofs_base + AFE_BASE_END_OFFSET,
			 memif->phys_buf_addr + memif->buffer_size - 1);

	/* set MSB to 33-bit */
	mtk_regmap_update_bits(afe->regmap, memif->data->msb_reg,
			       1 << memif->data->msb_shift,
			       msb_at_bit33 << memif->data->msb_shift);

	/* set channel */
	if (memif->data->mono_shift >= 0) {
		unsigned int mono = (params_channels(params) == 1) ? 1 : 0;

		mtk_regmap_update_bits(afe->regmap, memif->data->mono_reg,
				       1 << memif->data->mono_shift,
				       mono << memif->data->mono_shift);
	}

	/* set rate */
	if (memif->data->fs_shift < 0)
		return 0;

	fs = afe->memif_fs(substream, params_rate(params));

	if (fs < 0)
		return -EINVAL;

	mtk_regmap_update_bits(afe->regmap, memif->data->fs_reg,
			       memif->data->fs_maskbit << memif->data->fs_shift,
			       fs << memif->data->fs_shift);

	return 0;
}
EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_params);

int mtk_afe_fe_hw_free(struct snd_pcm_substream *substream,
		       struct snd_soc_dai *dai)
{
	return snd_pcm_lib_free_pages(substream);
}
EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_free);

int mtk_afe_fe_trigger(struct snd_pcm_substream *substream, int cmd,
		       struct snd_soc_dai *dai)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_pcm_runtime * const runtime = substream->runtime;
	struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
	struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
	struct mtk_base_afe_irq *irqs = &afe->irqs[memif->irq_usage];
	const struct mtk_base_irq_data *irq_data = irqs->irq_data;
	unsigned int counter = runtime->period_size;
	int fs;

	dev_dbg(afe->dev, "%s %s cmd=%d\n", __func__, memif->data->name, cmd);

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
	case SNDRV_PCM_TRIGGER_RESUME:
		if (memif->data->enable_shift >= 0)
			mtk_regmap_update_bits(afe->regmap,
					       memif->data->enable_reg,
					       1 << memif->data->enable_shift,
					       1 << memif->data->enable_shift);

		/* set irq counter */
		mtk_regmap_update_bits(afe->regmap, irq_data->irq_cnt_reg,
				       irq_data->irq_cnt_maskbit
				       << irq_data->irq_cnt_shift,
				       counter << irq_data->irq_cnt_shift);

		/* set irq fs */
		fs = afe->irq_fs(substream, runtime->rate);

		if (fs < 0)
			return -EINVAL;

		mtk_regmap_update_bits(afe->regmap, irq_data->irq_fs_reg,
				       irq_data->irq_fs_maskbit
				       << irq_data->irq_fs_shift,
				       fs << irq_data->irq_fs_shift);

		/* enable interrupt */
		mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg,
				       1 << irq_data->irq_en_shift,
				       1 << irq_data->irq_en_shift);

		return 0;
	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:
		mtk_regmap_update_bits(afe->regmap, memif->data->enable_reg,
				       1 << memif->data->enable_shift, 0);
		/* disable interrupt */
		mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg,
				       1 << irq_data->irq_en_shift,
				       0 << irq_data->irq_en_shift);
		/* and clear pending IRQ */
		mtk_regmap_write(afe->regmap, irq_data->irq_clr_reg,
				 1 << irq_data->irq_clr_shift);
		return 0;
	default:
		return -EINVAL;
	}
}
EXPORT_SYMBOL_GPL(mtk_afe_fe_trigger);

int mtk_afe_fe_prepare(struct snd_pcm_substream *substream,
		       struct snd_soc_dai *dai)
{
	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];
	int hd_audio = 0;

	/* set hd mode */
	switch (substream->runtime->format) {
	case SNDRV_PCM_FORMAT_S16_LE:
		hd_audio = 0;
		break;
	case SNDRV_PCM_FORMAT_S32_LE:
		hd_audio = 1;
		break;
	case SNDRV_PCM_FORMAT_S24_LE:
		hd_audio = 1;
		break;
	default:
		dev_err(afe->dev, "%s() error: unsupported format %d\n",
			__func__, substream->runtime->format);
		break;
	}

	mtk_regmap_update_bits(afe->regmap, memif->data->hd_reg,
			       1 << memif->data->hd_shift,
			       hd_audio << memif->data->hd_shift);

	return 0;
}
EXPORT_SYMBOL_GPL(mtk_afe_fe_prepare);

const struct snd_soc_dai_ops mtk_afe_fe_ops = {
	.startup	= mtk_afe_fe_startup,
	.shutdown	= mtk_afe_fe_shutdown,
	.hw_params	= mtk_afe_fe_hw_params,
	.hw_free	= mtk_afe_fe_hw_free,
	.prepare	= mtk_afe_fe_prepare,
	.trigger	= mtk_afe_fe_trigger,
};
EXPORT_SYMBOL_GPL(mtk_afe_fe_ops);

static DEFINE_MUTEX(irqs_lock);
int mtk_dynamic_irq_acquire(struct mtk_base_afe *afe)
{
	int i;

	mutex_lock(&afe->irq_alloc_lock);
	for (i = 0; i < afe->irqs_size; ++i) {
		if (afe->irqs[i].irq_occupyed == 0) {
			afe->irqs[i].irq_occupyed = 1;
			mutex_unlock(&afe->irq_alloc_lock);
			return i;
		}
	}
	mutex_unlock(&afe->irq_alloc_lock);
	return afe->irqs_size;
}
EXPORT_SYMBOL_GPL(mtk_dynamic_irq_acquire);

int mtk_dynamic_irq_release(struct mtk_base_afe *afe, int irq_id)
{
	mutex_lock(&afe->irq_alloc_lock);
	if (irq_id >= 0 && irq_id < afe->irqs_size) {
		afe->irqs[irq_id].irq_occupyed = 0;
		mutex_unlock(&afe->irq_alloc_lock);
		return 0;
	}
	mutex_unlock(&afe->irq_alloc_lock);
	return -EINVAL;
}
EXPORT_SYMBOL_GPL(mtk_dynamic_irq_release);

int mtk_afe_dai_suspend(struct snd_soc_dai *dai)
{
	struct mtk_base_afe *afe = dev_get_drvdata(dai->dev);
	struct device *dev = afe->dev;
	struct regmap *regmap = afe->regmap;
	int i;

	if (pm_runtime_status_suspended(dev) || afe->suspended)
		return 0;

	if (!afe->reg_back_up)
		afe->reg_back_up =
			devm_kcalloc(dev, afe->reg_back_up_list_num,
				     sizeof(unsigned int), GFP_KERNEL);

	for (i = 0; i < afe->reg_back_up_list_num; i++)
		regmap_read(regmap, afe->reg_back_up_list[i],
			    &afe->reg_back_up[i]);

	afe->suspended = true;
	afe->runtime_suspend(dev);
	return 0;
}
EXPORT_SYMBOL_GPL(mtk_afe_dai_suspend);

int mtk_afe_dai_resume(struct snd_soc_dai *dai)
{
	struct mtk_base_afe *afe = dev_get_drvdata(dai->dev);
	struct device *dev = afe->dev;
	struct regmap *regmap = afe->regmap;
	int i = 0;

	if (pm_runtime_status_suspended(dev) || !afe->suspended)
		return 0;

	afe->runtime_resume(dev);

	if (!afe->reg_back_up)
		dev_dbg(dev, "%s no reg_backup\n", __func__);

	for (i = 0; i < afe->reg_back_up_list_num; i++)
		mtk_regmap_write(regmap, afe->reg_back_up_list[i],
				 afe->reg_back_up[i]);

	afe->suspended = false;
	return 0;
}
EXPORT_SYMBOL_GPL(mtk_afe_dai_resume);

MODULE_DESCRIPTION("Mediatek simple fe dai operator");
MODULE_AUTHOR("Garlic Tseng <garlic.tseng@mediatek.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
283b6124 GT	1	/*
	2	* mtk-afe-fe-dais.c -- Mediatek afe fe dai operator
	3	*
	4	* Copyright (c) 2016 MediaTek Inc.
	5	* Author: Garlic Tseng <garlic.tseng@mediatek.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 and
	9	* only version 2 as published by the Free Software Foundation.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*/
	16
	17	#include <linux/module.h>
	18	#include <linux/pm_runtime.h>
	19	#include <linux/regmap.h>
	20	#include <sound/soc.h>
	21	#include "mtk-afe-fe-dai.h"
	22	#include "mtk-base-afe.h"
	23
	24	#define AFE_BASE_END_OFFSET 8
	25
22e76614 BX	26	static int mtk_regmap_update_bits(struct regmap *map, int reg,
22e76614 BX	27	unsigned int mask,
283b6124 GT	28	unsigned int val)
	29	{
	30	if (reg < 0)
	31	return 0;
	32	return regmap_update_bits(map, reg, mask, val);
	33	}
	34
22e76614	35	static int mtk_regmap_write(struct regmap *map, int reg, unsigned int val)
283b6124 GT	36	{
	37	if (reg < 0)
	38	return 0;
	39	return regmap_write(map, reg, val);
	40	}
	41
	42	int mtk_afe_fe_startup(struct snd_pcm_substream *substream,
	43	struct snd_soc_dai *dai)
	44	{
	45	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	46	struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
	47	struct snd_pcm_runtime *runtime = substream->runtime;
	48	int memif_num = rtd->cpu_dai->id;
	49	struct mtk_base_afe_memif *memif = &afe->memif[memif_num];
	50	const struct snd_pcm_hardware *mtk_afe_hardware = afe->mtk_afe_hardware;
	51	int ret;
	52
	53	memif->substream = substream;
	54
	55	snd_pcm_hw_constraint_step(substream->runtime, 0,
	56	SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 16);
	57	/* enable agent */
	58	mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg,
	59	1 << memif->data->agent_disable_shift,
	60	0 << memif->data->agent_disable_shift);
	61
	62	snd_soc_set_runtime_hwparams(substream, mtk_afe_hardware);
	63
	64	/*
	65	* Capture cannot use ping-pong buffer since hw_ptr at IRQ may be
	66	* smaller than period_size due to AFE's internal buffer.
	67	* This easily leads to overrun when avail_min is period_size.
	68	* One more period can hold the possible unread buffer.
	69	*/
	70	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
	71	int periods_max = mtk_afe_hardware->periods_max;
	72
	73	ret = snd_pcm_hw_constraint_minmax(runtime,
	74	SNDRV_PCM_HW_PARAM_PERIODS,
	75	3, periods_max);
	76	if (ret < 0) {
	77	dev_err(afe->dev, "hw_constraint_minmax failed\n");
	78	return ret;
	79	}
	80	}
	81
	82	ret = snd_pcm_hw_constraint_integer(runtime,
	83	SNDRV_PCM_HW_PARAM_PERIODS);
	84	if (ret < 0)
	85	dev_err(afe->dev, "snd_pcm_hw_constraint_integer failed\n");
	86
	87	/* dynamic allocate irq to memif */
	88	if (memif->irq_usage < 0) {
	89	int irq_id = mtk_dynamic_irq_acquire(afe);
	90
	91	if (irq_id != afe->irqs_size) {
	92	/* link */
	93	memif->irq_usage = irq_id;
	94	} else {
	95	dev_err(afe->dev, "%s() error: no more asys irq\n",
	96	__func__);
	97	ret = -EBUSY;
	98	}
	99	}
100	return ret;
101	}
102	EXPORT_SYMBOL_GPL(mtk_afe_fe_startup);
103
104	void mtk_afe_fe_shutdown(struct snd_pcm_substream *substream,
105	struct snd_soc_dai *dai)
106	{
107	struct snd_soc_pcm_runtime *rtd = substream->private_data;
108	struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
109	struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
110	int irq_id;
111
112	irq_id = memif->irq_usage;
113
114	mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg,
115	1 << memif->data->agent_disable_shift,
116	1 << memif->data->agent_disable_shift);
117
118	if (!memif->const_irq) {
119	mtk_dynamic_irq_release(afe, irq_id);
120	memif->irq_usage = -1;
121	memif->substream = NULL;
122	}
123	}
124	EXPORT_SYMBOL_GPL(mtk_afe_fe_shutdown);
125
126	int mtk_afe_fe_hw_params(struct snd_pcm_substream *substream,
127	struct snd_pcm_hw_params *params,
128	struct snd_soc_dai *dai)
129	{
130	struct snd_soc_pcm_runtime *rtd = substream->private_data;
131	struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
132	struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
133	int msb_at_bit33 = 0;
134	int ret, fs = 0;
135
136	ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
137	if (ret < 0)
138	return ret;
139
140	msb_at_bit33 = upper_32_bits(substream->runtime->dma_addr) ? 1 : 0;
141	memif->phys_buf_addr = lower_32_bits(substream->runtime->dma_addr);
142	memif->buffer_size = substream->runtime->dma_bytes;
143
144	/* start */
145	mtk_regmap_write(afe->regmap, memif->data->reg_ofs_base,
146	memif->phys_buf_addr);
147	/* end */
148	mtk_regmap_write(afe->regmap,
149	memif->data->reg_ofs_base + AFE_BASE_END_OFFSET,
150	memif->phys_buf_addr + memif->buffer_size - 1);
151
152	/* set MSB to 33-bit */
153	mtk_regmap_update_bits(afe->regmap, memif->data->msb_reg,
154	1 << memif->data->msb_shift,
155	msb_at_bit33 << memif->data->msb_shift);
156
157	/* set channel */
158	if (memif->data->mono_shift >= 0) {
159	unsigned int mono = (params_channels(params) == 1) ? 1 : 0;
160
161	mtk_regmap_update_bits(afe->regmap, memif->data->mono_reg,
162	1 << memif->data->mono_shift,
163	mono << memif->data->mono_shift);
164	}
165
166	/* set rate */
167	if (memif->data->fs_shift < 0)
168	return 0;
169
170	fs = afe->memif_fs(substream, params_rate(params));
171
172	if (fs < 0)
173	return -EINVAL;
174
175	mtk_regmap_update_bits(afe->regmap, memif->data->fs_reg,
176	memif->data->fs_maskbit << memif->data->fs_shift,
177	fs << memif->data->fs_shift);
178
179	return 0;
180	}
181	EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_params);
182
183	int mtk_afe_fe_hw_free(struct snd_pcm_substream *substream,
184	struct snd_soc_dai *dai)
185	{
186	return snd_pcm_lib_free_pages(substream);
187	}
188	EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_free);
189
190	int mtk_afe_fe_trigger(struct snd_pcm_substream *substream, int cmd,
191	struct snd_soc_dai *dai)
192	{
193	struct snd_soc_pcm_runtime *rtd = substream->private_data;
194	struct snd_pcm_runtime * const runtime = substream->runtime;
195	struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
196	struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
197	struct mtk_base_afe_irq *irqs = &afe->irqs[memif->irq_usage];
198	const struct mtk_base_irq_data *irq_data = irqs->irq_data;
199	unsigned int counter = runtime->period_size;
200	int fs;
201
202	dev_dbg(afe->dev, "%s %s cmd=%d\n", __func__, memif->data->name, cmd);
203
204	switch (cmd) {
205	case SNDRV_PCM_TRIGGER_START:
206	case SNDRV_PCM_TRIGGER_RESUME:
207	if (memif->data->enable_shift >= 0)
208	mtk_regmap_update_bits(afe->regmap,
209	memif->data->enable_reg,
210	1 << memif->data->enable_shift,
211	1 << memif->data->enable_shift);
212
213	/* set irq counter */
214	mtk_regmap_update_bits(afe->regmap, irq_data->irq_cnt_reg,
215	irq_data->irq_cnt_maskbit
216	<< irq_data->irq_cnt_shift,
217	counter << irq_data->irq_cnt_shift);
218
219	/* set irq fs */
220	fs = afe->irq_fs(substream, runtime->rate);
221
222	if (fs < 0)
223	return -EINVAL;
224
225	mtk_regmap_update_bits(afe->regmap, irq_data->irq_fs_reg,
226	irq_data->irq_fs_maskbit
227	<< irq_data->irq_fs_shift,
228	fs << irq_data->irq_fs_shift);
229
230	/* enable interrupt */
231	mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg,
232	1 << irq_data->irq_en_shift,
233	1 << irq_data->irq_en_shift);
234
235	return 0;
236	case SNDRV_PCM_TRIGGER_STOP:
237	case SNDRV_PCM_TRIGGER_SUSPEND:
238	mtk_regmap_update_bits(afe->regmap, memif->data->enable_reg,
239	1 << memif->data->enable_shift, 0);
240	/* disable interrupt */
241	mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg,
242	1 << irq_data->irq_en_shift,
243	0 << irq_data->irq_en_shift);
244	/* and clear pending IRQ */
245	mtk_regmap_write(afe->regmap, irq_data->irq_clr_reg,
246	1 << irq_data->irq_clr_shift);
247	return 0;
248	default:
249	return -EINVAL;
250	}
251	}
252	EXPORT_SYMBOL_GPL(mtk_afe_fe_trigger);
253
254	int mtk_afe_fe_prepare(struct snd_pcm_substream *substream,
255	struct snd_soc_dai *dai)
256	{
257	struct snd_soc_pcm_runtime *rtd = substream->private_data;
258	struct mtk_base_afe *afe = snd_soc_platform_get_drvdata(rtd->platform);
259	struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
260	int hd_audio = 0;
261
262	/* set hd mode */
263	switch (substream->runtime->format) {
264	case SNDRV_PCM_FORMAT_S16_LE:
265	hd_audio = 0;
266	break;
267	case SNDRV_PCM_FORMAT_S32_LE:
268	hd_audio = 1;
269	break;
270	case SNDRV_PCM_FORMAT_S24_LE:
271	hd_audio = 1;
272	break;
273	default:
274	dev_err(afe->dev, "%s() error: unsupported format %d\n",
275	__func__, substream->runtime->format);
276	break;
277	}
278
279	mtk_regmap_update_bits(afe->regmap, memif->data->hd_reg,
280	1 << memif->data->hd_shift,
281	hd_audio << memif->data->hd_shift);
282
283	return 0;
284	}
285	EXPORT_SYMBOL_GPL(mtk_afe_fe_prepare);
286
287	const struct snd_soc_dai_ops mtk_afe_fe_ops = {
288	.startup = mtk_afe_fe_startup,
289	.shutdown = mtk_afe_fe_shutdown,
290	.hw_params = mtk_afe_fe_hw_params,
291	.hw_free = mtk_afe_fe_hw_free,
292	.prepare = mtk_afe_fe_prepare,
293	.trigger = mtk_afe_fe_trigger,
294	};
295	EXPORT_SYMBOL_GPL(mtk_afe_fe_ops);
296
297	static DEFINE_MUTEX(irqs_lock);
298	int mtk_dynamic_irq_acquire(struct mtk_base_afe *afe)
299	{
300	int i;
301
302	mutex_lock(&afe->irq_alloc_lock);
303	for (i = 0; i < afe->irqs_size; ++i) {
304	if (afe->irqs[i].irq_occupyed == 0) {
305	afe->irqs[i].irq_occupyed = 1;
306	mutex_unlock(&afe->irq_alloc_lock);
307	return i;
308	}
309	}
310	mutex_unlock(&afe->irq_alloc_lock);
311	return afe->irqs_size;
312	}
313	EXPORT_SYMBOL_GPL(mtk_dynamic_irq_acquire);
314
315	int mtk_dynamic_irq_release(struct mtk_base_afe *afe, int irq_id)
316	{
317	mutex_lock(&afe->irq_alloc_lock);
318	if (irq_id >= 0 && irq_id < afe->irqs_size) {
319	afe->irqs[irq_id].irq_occupyed = 0;
320	mutex_unlock(&afe->irq_alloc_lock);
321	return 0;
322	}
323	mutex_unlock(&afe->irq_alloc_lock);
324	return -EINVAL;
325	}
326	EXPORT_SYMBOL_GPL(mtk_dynamic_irq_release);
327
328	int mtk_afe_dai_suspend(struct snd_soc_dai *dai)
329	{
330	struct mtk_base_afe *afe = dev_get_drvdata(dai->dev);
331	struct device *dev = afe->dev;
332	struct regmap *regmap = afe->regmap;
333	int i;
334
335	if (pm_runtime_status_suspended(dev) \|\| afe->suspended)
336	return 0;
337
338	if (!afe->reg_back_up)
339	afe->reg_back_up =
340	devm_kcalloc(dev, afe->reg_back_up_list_num,
341	sizeof(unsigned int), GFP_KERNEL);
342
343	for (i = 0; i < afe->reg_back_up_list_num; i++)
344	regmap_read(regmap, afe->reg_back_up_list[i],
345	&afe->reg_back_up[i]);
346
347	afe->suspended = true;
348	afe->runtime_suspend(dev);
349	return 0;
350	}
351	EXPORT_SYMBOL_GPL(mtk_afe_dai_suspend);
352
353	int mtk_afe_dai_resume(struct snd_soc_dai *dai)
354	{
355	struct mtk_base_afe *afe = dev_get_drvdata(dai->dev);
356	struct device *dev = afe->dev;
357	struct regmap *regmap = afe->regmap;
358	int i = 0;
359
360	if (pm_runtime_status_suspended(dev) \|\| !afe->suspended)
361	return 0;
362
363	afe->runtime_resume(dev);
364
365	if (!afe->reg_back_up)
366	dev_dbg(dev, "%s no reg_backup\n", __func__);
367
368	for (i = 0; i < afe->reg_back_up_list_num; i++)
369	mtk_regmap_write(regmap, afe->reg_back_up_list[i],
370	afe->reg_back_up[i]);
371
372	afe->suspended = false;
373	return 0;
374	}
375	EXPORT_SYMBOL_GPL(mtk_afe_dai_resume);
376
377	MODULE_DESCRIPTION("Mediatek simple fe dai operator");
378	MODULE_AUTHOR("Garlic Tseng <garlic.tseng@mediatek.com>");
379	MODULE_LICENSE("GPL v2");
380