#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/pm_runtime.h>
#include <linux/reset.h>
#include "an7581-afe-common.h"
#include "an7581-reg.h"
#include "../common/mtk-afe-platform-driver.h"
#include "../common/mtk-afe-fe-dai.h"
enum {
ARH_AFE_RATE_8K = 0,
ARH_AFE_RATE_12K = 1,
ARH_AFE_RATE_16K = 2,
ARH_AFE_RATE_24K = 3,
ARH_AFE_RATE_32K = 4,
ARH_AFE_RATE_48K = 5,
ARH_AFE_RATE_96K = 6,
ARH_AFE_RATE_192K = 7,
ARH_AFE_RATE_384K = 8,
ARH_AFE_RATE_7K = 16,
ARH_AFE_RATE_11K = 17,
ARH_AFE_RATE_14K = 18,
ARH_AFE_RATE_22K = 19,
ARH_AFE_RATE_29K = 20,
ARH_AFE_RATE_44K = 21,
ARH_AFE_RATE_88K = 22,
ARH_AFE_RATE_176K = 23,
ARH_AFE_RATE_352K = 24,
};
unsigned int an7581_afe_rate_transform(struct device *dev, unsigned int rate)
{
switch (rate) {
case 7350:
return ARH_AFE_RATE_7K;
case 8000:
return ARH_AFE_RATE_8K;
case 11025:
return ARH_AFE_RATE_11K;
case 12000:
return ARH_AFE_RATE_12K;
case 14700:
return ARH_AFE_RATE_14K;
case 16000:
return ARH_AFE_RATE_16K;
case 22050:
return ARH_AFE_RATE_22K;
case 24000:
return ARH_AFE_RATE_24K;
case 29400:
return ARH_AFE_RATE_29K;
case 32000:
return ARH_AFE_RATE_32K;
case 44100:
return ARH_AFE_RATE_44K;
case 48000:
return ARH_AFE_RATE_48K;
case 88200:
return ARH_AFE_RATE_88K;
case 96000:
return ARH_AFE_RATE_96K;
case 176400:
return ARH_AFE_RATE_176K;
case 192000:
return ARH_AFE_RATE_192K;
case 352800:
return ARH_AFE_RATE_352K;
case 384000:
return ARH_AFE_RATE_384K;
default:
dev_warn_ratelimited(dev, "%s(), rate %u invalid, using %d!\n",
__func__, rate, ARH_AFE_RATE_48K);
return ARH_AFE_RATE_48K;
}
}
static const struct an7581_memif_irq_desc an7581_memif_irq_descs[AN7581_MEMIF_NUM] = {
[AN7581_MEMIF_DL1] = {
.irq = AN7581_IRQ_0,
.status_bit = AFE_IRQ_STS_PLAY,
.clear_reg = AFE_IRQ_CON0,
},
[AN7581_MEMIF_UL1] = {
.irq = AN7581_IRQ_1,
.status_bit = AFE_IRQ_STS_RECORD,
.clear_reg = AFE_IRQ1_CON0,
},
};
static const struct snd_pcm_hardware an7581_afe_hardware = {
.info = SNDRV_PCM_INFO_MMAP |
SNDRV_PCM_INFO_INTERLEAVED |
SNDRV_PCM_INFO_MMAP_VALID,
.formats = SNDRV_PCM_FMTBIT_S16_LE |
SNDRV_PCM_FMTBIT_S24_LE |
SNDRV_PCM_FMTBIT_S32_LE,
.period_bytes_min = 512,
.period_bytes_max = 128 * 1024,
.periods_min = 2,
.periods_max = 256,
.buffer_bytes_max = 256 * 1024,
};
static int an7581_memif_irq_fs(struct snd_pcm_substream *substream, unsigned int rate)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd, AFE_PCM_NAME);
struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);
return an7581_afe_rate_transform(afe->dev, rate);
}
static int an7581_afe_fe_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
int ret;
ret = mtk_afe_fe_startup(substream, dai);
if (ret < 0)
return ret;
if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
ret = snd_pcm_hw_constraint_minmax(runtime,
SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
0x2000, UINT_MAX);
if (ret < 0)
dev_err(afe->dev, "hw_constraint_minmax failed\n");
}
return ret;
}
static const struct snd_soc_dai_ops an7581_afe_fe_ops = {
.startup = an7581_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,
};
#define ARH_PCM_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
SNDRV_PCM_FMTBIT_S32_LE)
static struct snd_soc_dai_driver an7581_memif_dai_driver[] = {
{
.name = "DL1",
.id = AN7581_MEMIF_DL1,
.playback = {
.stream_name = "DL1",
.channels_min = 1,
.channels_max = 8,
.rates = SNDRV_PCM_RATE_8000_192000,
.formats = ARH_PCM_FORMATS,
},
.ops = &an7581_afe_fe_ops,
},
{
.name = "UL1",
.id = AN7581_MEMIF_UL1,
.capture = {
.stream_name = "UL1",
.channels_min = 1,
.channels_max = 8,
.rates = SNDRV_PCM_RATE_8000_192000,
.formats = ARH_PCM_FORMATS,
},
.ops = &an7581_afe_fe_ops,
},
};
static const struct snd_soc_dapm_widget an7581_memif_widgets[] = {
SND_SOC_DAPM_MIXER("I032", SND_SOC_NOPM, 0, 0, NULL, 0),
SND_SOC_DAPM_MIXER("I033", SND_SOC_NOPM, 0, 0, NULL, 0),
SND_SOC_DAPM_MIXER("O018", SND_SOC_NOPM, 0, 0, NULL, 0),
SND_SOC_DAPM_MIXER("O019", SND_SOC_NOPM, 0, 0, NULL, 0),
};
static const struct snd_soc_dapm_route an7581_memif_routes[] = {
{"I032", NULL, "DL1"},
{"I033", NULL, "DL1"},
{"UL1", NULL, "O018"},
{"UL1", NULL, "O019"},
{"O018", NULL, "I150"},
{"O019", NULL, "I151"},
};
static const struct snd_soc_component_driver an7581_afe_pcm_dai_component = {
.name = "an7581-afe-pcm-dai",
};
static const struct mtk_base_memif_data memif_data[AN7581_MEMIF_NUM] = {
[AN7581_MEMIF_DL1] = {
.name = "DL1",
.id = AN7581_MEMIF_DL1,
.reg_ofs_base = AFE_DL1_BASE,
.reg_ofs_cur = AFE_DL1_CUR,
.reg_ofs_end = AFE_DL1_END,
.fs_reg = -1,
.fs_shift = -1,
.fs_maskbit = -1,
.mono_reg = -1,
.mono_shift = -1,
.hd_reg = AFE_DL1_CON0,
.hd_shift = AFE_HD_SHIFT,
.hd_align_reg = -1,
.hd_align_mshift = -1,
.enable_reg = AFE_DAC_CON0,
.enable_shift = AFE_DL1_ENABLE_SHIFT,
.msb_reg = -1,
.msb_shift = -1,
.agent_disable_reg = -1,
.agent_disable_shift = -1,
},
[AN7581_MEMIF_UL1] = {
.name = "UL1",
.id = AN7581_MEMIF_UL1,
.reg_ofs_base = AFE_UL1_BASE,
.reg_ofs_cur = AFE_UL1_CUR,
.reg_ofs_end = AFE_UL1_END,
.fs_reg = -1,
.fs_shift = -1,
.fs_maskbit = -1,
.mono_reg = -1,
.mono_shift = -1,
.hd_reg = AFE_UL1_CON0,
.hd_shift = AFE_HD_SHIFT,
.hd_align_reg = AFE_UL1_CON0,
.hd_align_mshift = AFE_HD_ALIGN_SHIFT,
.enable_reg = AFE_DAC_CON0,
.enable_shift = AFE_UL1_ENABLE_SHIFT,
.msb_reg = -1,
.msb_shift = -1,
.agent_disable_reg = -1,
.agent_disable_shift = -1,
},
};
static const struct mtk_base_irq_data irq_data[AN7581_IRQ_NUM] = {
[AN7581_IRQ_0] = {
.id = AN7581_IRQ_0,
.irq_cnt_reg = AFE_IRQ_CNT,
.irq_cnt_shift = AFE_IRQ_CNT_SHIFT,
.irq_cnt_maskbit = AFE_IRQ_CNT_MASK,
.irq_en_reg = AFE_IRQ_CON0,
.irq_en_shift = AFE_IRQ_ON_SHIFT,
.irq_fs_reg = -1,
.irq_fs_shift = -1,
.irq_fs_maskbit = -1,
.irq_clr_reg = -1,
.irq_clr_shift = -1,
},
[AN7581_IRQ_1] = {
.id = AN7581_IRQ_1,
.irq_cnt_reg = AFE_IRQ1_CNT,
.irq_cnt_shift = AFE_IRQ_CNT_SHIFT,
.irq_cnt_maskbit = AFE_IRQ_CNT_MASK,
.irq_en_reg = AFE_IRQ1_CON0,
.irq_en_shift = AFE_IRQ_ON_SHIFT,
.irq_fs_reg = -1,
.irq_fs_shift = -1,
.irq_fs_maskbit = -1,
.irq_clr_reg = -1,
.irq_clr_shift = -1,
},
};
static const struct regmap_config an7581_afe_regmap_config = {
.name = "afe",
.reg_bits = 32,
.reg_stride = 4,
.val_bits = 32,
.max_register = AFE_MAX_REGISTER,
};
static const struct regmap_config an7581_afe_irq1_regmap_config = {
.name = "afe_irq1",
.reg_bits = 32,
.reg_stride = 4,
.val_bits = 32,
.max_register = AFE_IRQ1_MAX_REGISTER,
};
static irqreturn_t an7581_afe_irq_handler(int irq_id, void *dev)
{
const struct an7581_memif_irq_desc *irq_desc;
struct mtk_base_afe *afe = dev;
u32 status = 0;
int i;
regmap_read(afe->regmap, AFE_IRQ_STS, &status);
for (i = 0; i < AN7581_MEMIF_NUM; i++) {
struct mtk_base_afe_memif *memif = &afe->memif[i];
if (!memif->substream)
continue;
if (memif->irq_usage < 0)
continue;
irq_desc = &an7581_memif_irq_descs[i];
if (status & irq_desc->status_bit)
snd_pcm_period_elapsed(memif->substream);
}
for (i = 0; i < AN7581_MEMIF_NUM; i++) {
struct regmap *irq_regmap;
irq_desc = &an7581_memif_irq_descs[i];
if (!(status & irq_desc->status_bit))
continue;
irq_regmap = afe->irqs[irq_desc->irq].regmap;
regmap_set_bits(irq_regmap, irq_desc->clear_reg,
BIT(AFE_IRQ_CLR_SHIFT));
regmap_clear_bits(irq_regmap, irq_desc->clear_reg,
BIT(AFE_IRQ_CLR_SHIFT));
regmap_set_bits(irq_regmap, irq_desc->clear_reg,
BIT(AFE_IRQ_MISS_FLG_CLR_SHIFT));
regmap_clear_bits(irq_regmap, irq_desc->clear_reg,
BIT(AFE_IRQ_MISS_FLG_CLR_SHIFT));
}
return IRQ_HANDLED;
}
static int an7581_dai_memif_register(struct mtk_base_afe *afe)
{
struct mtk_base_afe_dai *dai;
dai = devm_kzalloc_obj(afe->dev, *dai);
if (!dai)
return -ENOMEM;
list_add(&dai->list, &afe->sub_dais);
dai->dai_drivers = an7581_memif_dai_driver;
dai->num_dai_drivers = ARRAY_SIZE(an7581_memif_dai_driver);
dai->dapm_widgets = an7581_memif_widgets;
dai->num_dapm_widgets = ARRAY_SIZE(an7581_memif_widgets);
dai->dapm_routes = an7581_memif_routes;
dai->num_dapm_routes = ARRAY_SIZE(an7581_memif_routes);
return 0;
}
typedef int (*dai_register_cb)(struct mtk_base_afe *);
static const dai_register_cb dai_register_cbs[] = {
an7581_dai_etdm_register,
an7581_dai_memif_register,
};
static int an7581_afe_pcm_dev_probe(struct platform_device *pdev)
{
struct an7581_afe_private *afe_priv;
struct device *dev = &pdev->dev;
struct reset_control *reset;
struct mtk_base_afe *afe;
int i, irq_id, ret;
void __iomem *base;
afe = devm_kzalloc_obj(dev, *afe);
if (!afe)
return -ENOMEM;
platform_set_drvdata(pdev, afe);
afe->platform_priv = devm_kzalloc_obj(dev, *afe_priv);
if (!afe->platform_priv)
return -ENOMEM;
afe->irqs_size = AN7581_IRQ_NUM;
afe->irqs = devm_kzalloc_objs(dev, *afe->irqs, afe->irqs_size);
if (!afe->irqs)
return -ENOMEM;
afe->memif_size = AN7581_MEMIF_NUM;
afe->memif = devm_kzalloc_objs(dev, *afe->memif, afe->memif_size);
if (!afe->memif)
return -ENOMEM;
afe_priv = afe->platform_priv;
mutex_init(&afe_priv->user_lock);
afe->dev = &pdev->dev;
reset = devm_reset_control_get_exclusive(dev, NULL);
if (IS_ERR(reset))
return PTR_ERR(reset);
reset_control_assert(reset);
usleep_range(10, 20);
reset_control_deassert(reset);
afe->base_addr = devm_platform_ioremap_resource(pdev, 0);
if (IS_ERR(afe->base_addr))
return PTR_ERR(afe->base_addr);
base = devm_platform_ioremap_resource(pdev, 1);
if (IS_ERR(base))
return PTR_ERR(base);
ret = devm_pm_runtime_enable(dev);
if (ret)
return ret;
afe->regmap = devm_regmap_init_mmio(&pdev->dev, afe->base_addr,
&an7581_afe_regmap_config);
if (IS_ERR(afe->regmap))
return PTR_ERR(afe->regmap);
mutex_init(&afe->irq_alloc_lock);
for (i = 0; i < afe->irqs_size; i++)
afe->irqs[i].irq_data = &irq_data[i];
afe->irqs[AN7581_IRQ_0].regmap = afe->regmap;
afe->irqs[AN7581_IRQ_1].regmap = devm_regmap_init_mmio(&pdev->dev, base,
&an7581_afe_irq1_regmap_config);
if (IS_ERR(afe->irqs[AN7581_IRQ_1].regmap))
return PTR_ERR(afe->irqs[AN7581_IRQ_1].regmap);
irq_id = platform_get_irq(pdev, 0);
if (irq_id < 0)
return irq_id;
for (i = 0; i < afe->memif_size; i++) {
int sel_irq = an7581_memif_irq_descs[i].irq;
afe->memif[i].data = &memif_data[i];
afe->memif[i].irq_usage = sel_irq;
afe->memif[i].const_irq = 1;
afe->irqs[sel_irq].irq_occupyed = true;
}
INIT_LIST_HEAD(&afe->sub_dais);
ret = devm_request_irq(dev, irq_id, an7581_afe_irq_handler,
IRQF_TRIGGER_NONE, "asys-isr", (void *)afe);
if (ret)
return dev_err_probe(dev, ret, "Failed to request irq for asys-isr\n");
for (i = 0; i < ARRAY_SIZE(dai_register_cbs); i++) {
ret = dai_register_cbs[i](afe);
if (ret)
return dev_err_probe(dev, ret, "DAI register failed, i: %d\n", i);
}
ret = mtk_afe_combine_sub_dai(afe);
if (ret)
return dev_err_probe(dev, ret, "mtk_afe_combine_sub_dai fail\n");
afe->mtk_afe_hardware = &an7581_afe_hardware;
afe->memif_fs = an7581_memif_irq_fs;
afe->irq_fs = an7581_memif_irq_fs;
ret = devm_snd_soc_register_component(&pdev->dev,
&mtk_afe_pcm_platform,
NULL, 0);
if (ret)
return dev_err_probe(dev, ret, "Cannot register AFE component\n");
ret = devm_snd_soc_register_component(afe->dev,
&an7581_afe_pcm_dai_component,
afe->dai_drivers,
afe->num_dai_drivers);
if (ret)
return dev_err_probe(dev, ret, "Cannot register PCM DAI component\n");
return 0;
}
static const struct of_device_id an7581_afe_pcm_dt_match[] = {
{ .compatible = "airoha,an7581-afe" },
{ }
};
MODULE_DEVICE_TABLE(of, an7581_afe_pcm_dt_match);
static struct platform_driver an7581_afe_pcm_driver = {
.driver = {
.name = "an7581-audio",
.of_match_table = an7581_afe_pcm_dt_match,
},
.probe = an7581_afe_pcm_dev_probe,
};
module_platform_driver(an7581_afe_pcm_driver);
MODULE_DESCRIPTION("Airoha SoC AFE platform driver for ALSA AN7581");
MODULE_LICENSE("GPL"