mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-17 17:06:41 +07:00
2b27bdcc20
Based on 1 normalized pattern(s): this program is free software you can redistribute it and or modify it under the terms of the gnu general public license 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 you should have received a copy of the gnu general public license along with this program if not write to the free software foundation inc 51 franklin st fifth floor boston ma 02110 1301 usa extracted by the scancode license scanner the SPDX license identifier GPL-2.0-only has been chosen to replace the boilerplate/reference in 246 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Alexios Zavras <alexios.zavras@intel.com> Reviewed-by: Allison Randal <allison@lohutok.net> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190530000436.674189849@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
192 lines
4.5 KiB
C
192 lines
4.5 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* dmic.c -- SoC audio for Generic Digital MICs
|
|
*
|
|
* Author: Liam Girdwood <lrg@slimlogic.co.uk>
|
|
*/
|
|
|
|
#include <linux/delay.h>
|
|
#include <linux/gpio.h>
|
|
#include <linux/gpio/consumer.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/module.h>
|
|
#include <sound/core.h>
|
|
#include <sound/pcm.h>
|
|
#include <sound/soc.h>
|
|
#include <sound/soc-dapm.h>
|
|
|
|
#define MAX_MODESWITCH_DELAY 70
|
|
static int modeswitch_delay;
|
|
module_param(modeswitch_delay, uint, 0644);
|
|
|
|
static int wakeup_delay;
|
|
module_param(wakeup_delay, uint, 0644);
|
|
|
|
struct dmic {
|
|
struct gpio_desc *gpio_en;
|
|
int wakeup_delay;
|
|
/* Delay after DMIC mode switch */
|
|
int modeswitch_delay;
|
|
};
|
|
|
|
static int dmic_daiops_trigger(struct snd_pcm_substream *substream,
|
|
int cmd, struct snd_soc_dai *dai)
|
|
{
|
|
struct snd_soc_component *component = dai->component;
|
|
struct dmic *dmic = snd_soc_component_get_drvdata(component);
|
|
|
|
switch (cmd) {
|
|
case SNDRV_PCM_TRIGGER_STOP:
|
|
if (dmic->modeswitch_delay)
|
|
mdelay(dmic->modeswitch_delay);
|
|
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct snd_soc_dai_ops dmic_dai_ops = {
|
|
.trigger = dmic_daiops_trigger,
|
|
};
|
|
|
|
static int dmic_aif_event(struct snd_soc_dapm_widget *w,
|
|
struct snd_kcontrol *kcontrol, int event) {
|
|
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
|
|
struct dmic *dmic = snd_soc_component_get_drvdata(component);
|
|
|
|
switch (event) {
|
|
case SND_SOC_DAPM_POST_PMU:
|
|
if (dmic->gpio_en)
|
|
gpiod_set_value(dmic->gpio_en, 1);
|
|
|
|
if (dmic->wakeup_delay)
|
|
msleep(dmic->wakeup_delay);
|
|
break;
|
|
case SND_SOC_DAPM_POST_PMD:
|
|
if (dmic->gpio_en)
|
|
gpiod_set_value(dmic->gpio_en, 0);
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct snd_soc_dai_driver dmic_dai = {
|
|
.name = "dmic-hifi",
|
|
.capture = {
|
|
.stream_name = "Capture",
|
|
.channels_min = 1,
|
|
.channels_max = 8,
|
|
.rates = SNDRV_PCM_RATE_CONTINUOUS,
|
|
.formats = SNDRV_PCM_FMTBIT_S32_LE
|
|
| SNDRV_PCM_FMTBIT_S24_LE
|
|
| SNDRV_PCM_FMTBIT_S16_LE,
|
|
},
|
|
.ops = &dmic_dai_ops,
|
|
};
|
|
|
|
static int dmic_component_probe(struct snd_soc_component *component)
|
|
{
|
|
struct dmic *dmic;
|
|
|
|
dmic = devm_kzalloc(component->dev, sizeof(*dmic), GFP_KERNEL);
|
|
if (!dmic)
|
|
return -ENOMEM;
|
|
|
|
dmic->gpio_en = devm_gpiod_get_optional(component->dev,
|
|
"dmicen", GPIOD_OUT_LOW);
|
|
if (IS_ERR(dmic->gpio_en))
|
|
return PTR_ERR(dmic->gpio_en);
|
|
|
|
device_property_read_u32(component->dev, "wakeup-delay-ms",
|
|
&dmic->wakeup_delay);
|
|
device_property_read_u32(component->dev, "modeswitch-delay-ms",
|
|
&dmic->modeswitch_delay);
|
|
if (wakeup_delay)
|
|
dmic->wakeup_delay = wakeup_delay;
|
|
if (modeswitch_delay)
|
|
dmic->modeswitch_delay = modeswitch_delay;
|
|
|
|
if (dmic->modeswitch_delay > MAX_MODESWITCH_DELAY)
|
|
dmic->modeswitch_delay = MAX_MODESWITCH_DELAY;
|
|
|
|
snd_soc_component_set_drvdata(component, dmic);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct snd_soc_dapm_widget dmic_dapm_widgets[] = {
|
|
SND_SOC_DAPM_AIF_OUT_E("DMIC AIF", "Capture", 0,
|
|
SND_SOC_NOPM, 0, 0, dmic_aif_event,
|
|
SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
|
|
SND_SOC_DAPM_INPUT("DMic"),
|
|
};
|
|
|
|
static const struct snd_soc_dapm_route intercon[] = {
|
|
{"DMIC AIF", NULL, "DMic"},
|
|
};
|
|
|
|
static const struct snd_soc_component_driver soc_dmic = {
|
|
.probe = dmic_component_probe,
|
|
.dapm_widgets = dmic_dapm_widgets,
|
|
.num_dapm_widgets = ARRAY_SIZE(dmic_dapm_widgets),
|
|
.dapm_routes = intercon,
|
|
.num_dapm_routes = ARRAY_SIZE(intercon),
|
|
.idle_bias_on = 1,
|
|
.use_pmdown_time = 1,
|
|
.endianness = 1,
|
|
.non_legacy_dai_naming = 1,
|
|
};
|
|
|
|
static int dmic_dev_probe(struct platform_device *pdev)
|
|
{
|
|
int err;
|
|
u32 chans;
|
|
struct snd_soc_dai_driver *dai_drv = &dmic_dai;
|
|
|
|
if (pdev->dev.of_node) {
|
|
err = of_property_read_u32(pdev->dev.of_node, "num-channels", &chans);
|
|
if (err && (err != -EINVAL))
|
|
return err;
|
|
|
|
if (!err) {
|
|
if (chans < 1 || chans > 8)
|
|
return -EINVAL;
|
|
|
|
dai_drv = devm_kzalloc(&pdev->dev, sizeof(*dai_drv), GFP_KERNEL);
|
|
if (!dai_drv)
|
|
return -ENOMEM;
|
|
|
|
memcpy(dai_drv, &dmic_dai, sizeof(*dai_drv));
|
|
dai_drv->capture.channels_max = chans;
|
|
}
|
|
}
|
|
|
|
return devm_snd_soc_register_component(&pdev->dev,
|
|
&soc_dmic, dai_drv, 1);
|
|
}
|
|
|
|
MODULE_ALIAS("platform:dmic-codec");
|
|
|
|
static const struct of_device_id dmic_dev_match[] = {
|
|
{.compatible = "dmic-codec"},
|
|
{}
|
|
};
|
|
MODULE_DEVICE_TABLE(of, dmic_dev_match);
|
|
|
|
static struct platform_driver dmic_driver = {
|
|
.driver = {
|
|
.name = "dmic-codec",
|
|
.of_match_table = dmic_dev_match,
|
|
},
|
|
.probe = dmic_dev_probe,
|
|
};
|
|
|
|
module_platform_driver(dmic_driver);
|
|
|
|
MODULE_DESCRIPTION("Generic DMIC driver");
|
|
MODULE_AUTHOR("Liam Girdwood <lrg@slimlogic.co.uk>");
|
|
MODULE_LICENSE("GPL");
|