forked from Minki/linux
bcb46a0e0e
you might feel like a deja vu to receive a bulk of changes at rc5, and it happens again; we've got a collection of fixes for ASoC. Most of fixes are targeted for the newly merged SOF (Sound Open Firmware) stuff and the relevant fixes for Intel platforms. Other than that, there are a few regression fixes for the recent ASoC core changes and HD-audio quirk, as well as a couple of FireWire fixes and for other ASoC codecs. -----BEGIN PGP SIGNATURE----- iQJCBAABCAAsFiEEIXTw5fNLNI7mMiVaLtJE4w1nLE8FAl0DY4YOHHRpd2FpQHN1 c2UuZGUACgkQLtJE4w1nLE/X9BAAzLc3OXBQhnQfFGvAmW8ro/bRuhwg3KjptwNe Zd/y6V4ru2Lhuqbr+EZMZqu665EkTg1CpHydMwsmD7bbmi47Xet7ocufjQMgHKcX l+QVRvzB+Ve5ARdUww8B6jqoc7CvZiM/tcW9VP3kphXOD4/iY1VcnRbVzHGYrAgI drLCnlC91Z5ssWPmAjuju6vZUwqCQupALs0wtdRFnwRonz0sCcPKjKzPAoS6KVQS 6kzRW3nLqKMpatbXdaSjb5tdVxRax8042sqaCqppvE1ToxvkbvSZykOwLQGDdCDn zkHUv+hmS76IV2Q4baCkAl4fkborKOJXgNQnoxQ5VDbOzBbOMy6867jQ+Y3gEx8k UqGpS2AA46c3pQcUvos0KqqHaSe3ESP2sH02k0BWWpmnyo927MAYE7qm80BnqjmJ emXXs0I5u5MkUBb00jP2QpvZqhoKzRLD84BWuHSlg5gIDCQ1cn1WIQaq8YIT4+Bf V50QUZMPI3PIw1g81XYLZXbhT/0b3zurOOhwEChPyJdz1ZoIyEeGMxt1rsZWD64B qn24AzRfIQTDteIYUmYovUtzZeFcAqQDsbtLQa98BzDHAYhvJEc+1bbT/NYgtv7/ zJqeFX9CbOcDihmiThvZKVAfThQeUCSWFBXk5JgBxs19uUa4et7XCHbXmPeyBJiq gF2xAhs= =9U0L -----END PGP SIGNATURE----- Merge tag 'sound-5.2-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound Pull sound fixes from Takashi Iwai: "It might feel like deja vu to receive a bulk of changes at rc5, and it happens again; we've got a collection of fixes for ASoC. Most of fixes are targeted for the newly merged SOF (Sound Open Firmware) stuff and the relevant fixes for Intel platforms. Other than that, there are a few regression fixes for the recent ASoC core changes and HD-audio quirk, as well as a couple of FireWire fixes and for other ASoC codecs" * tag 'sound-5.2-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound: (54 commits) Revert "ALSA: hda/realtek - Improve the headset mic for Acer Aspire laptops" ALSA: ice1712: Check correct return value to snd_i2c_sendbytes (EWS/DMX 6Fire) ALSA: oxfw: allow PCM capture for Stanton SCS.1m ALSA: firewire-motu: fix destruction of data for isochronous resources ASoC: Intel: sst: fix kmalloc call with wrong flags ASoC: core: Fix deadlock in snd_soc_instantiate_card() SoC: rt274: Fix internal jack assignment in set_jack callback ALSA: hdac: fix memory release for SST and SOF drivers ASoC: SOF: Intel: hda: use the defined ppcap functions ASoC: core: move DAI pre-links initiation to snd_soc_instantiate_card ASoC: Intel: cht_bsw_rt5672: fix kernel oops with platform_name override ASoC: Intel: cht_bsw_nau8824: fix kernel oops with platform_name override ASoC: Intel: bytcht_es8316: fix kernel oops with platform_name override ASoC: Intel: cht_bsw_max98090: fix kernel oops with platform_name override ASoC: sun4i-i2s: Add offset to RX channel select ASoC: sun4i-i2s: Fix sun8i tx channel offset mask ASoC: max98090: remove 24-bit format support if RJ is 0 ASoC: da7219: Fix build error without CONFIG_I2C ASoC: SOF: Intel: hda: Fix COMPILE_TEST build error ASoC: SOF: fix DSP oops definitions in FW ABI ...
524 lines
14 KiB
C
524 lines
14 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* cht-bsw-max98090.c - ASoc Machine driver for Intel Cherryview-based
|
|
* platforms Cherrytrail and Braswell, with max98090 & TI codec.
|
|
*
|
|
* Copyright (C) 2015 Intel Corp
|
|
* Author: Fang, Yang A <yang.a.fang@intel.com>
|
|
* This file is modified from cht_bsw_rt5645.c
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
*
|
|
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
*/
|
|
|
|
#include <linux/dmi.h>
|
|
#include <linux/module.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/acpi.h>
|
|
#include <linux/clk.h>
|
|
#include <sound/pcm.h>
|
|
#include <sound/pcm_params.h>
|
|
#include <sound/soc.h>
|
|
#include <sound/soc-acpi.h>
|
|
#include <sound/jack.h>
|
|
#include "../../codecs/max98090.h"
|
|
#include "../atom/sst-atom-controls.h"
|
|
#include "../../codecs/ts3a227e.h"
|
|
|
|
#define CHT_PLAT_CLK_3_HZ 19200000
|
|
#define CHT_CODEC_DAI "HiFi"
|
|
|
|
#define QUIRK_PMC_PLT_CLK_0 0x01
|
|
|
|
struct cht_mc_private {
|
|
struct clk *mclk;
|
|
struct snd_soc_jack jack;
|
|
bool ts3a227e_present;
|
|
int quirks;
|
|
};
|
|
|
|
static int platform_clock_control(struct snd_soc_dapm_widget *w,
|
|
struct snd_kcontrol *k, int event)
|
|
{
|
|
struct snd_soc_dapm_context *dapm = w->dapm;
|
|
struct snd_soc_card *card = dapm->card;
|
|
struct snd_soc_dai *codec_dai;
|
|
struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card);
|
|
int ret;
|
|
|
|
/* See the comment in snd_cht_mc_probe() */
|
|
if (ctx->quirks & QUIRK_PMC_PLT_CLK_0)
|
|
return 0;
|
|
|
|
codec_dai = snd_soc_card_get_codec_dai(card, CHT_CODEC_DAI);
|
|
if (!codec_dai) {
|
|
dev_err(card->dev, "Codec dai not found; Unable to set platform clock\n");
|
|
return -EIO;
|
|
}
|
|
|
|
if (SND_SOC_DAPM_EVENT_ON(event)) {
|
|
ret = clk_prepare_enable(ctx->mclk);
|
|
if (ret < 0) {
|
|
dev_err(card->dev,
|
|
"could not configure MCLK state");
|
|
return ret;
|
|
}
|
|
} else {
|
|
clk_disable_unprepare(ctx->mclk);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct snd_soc_dapm_widget cht_dapm_widgets[] = {
|
|
SND_SOC_DAPM_HP("Headphone", NULL),
|
|
SND_SOC_DAPM_MIC("Headset Mic", NULL),
|
|
SND_SOC_DAPM_MIC("Int Mic", NULL),
|
|
SND_SOC_DAPM_SPK("Ext Spk", NULL),
|
|
SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0,
|
|
platform_clock_control, SND_SOC_DAPM_PRE_PMU |
|
|
SND_SOC_DAPM_POST_PMD),
|
|
};
|
|
|
|
static const struct snd_soc_dapm_route cht_audio_map[] = {
|
|
{"IN34", NULL, "Headset Mic"},
|
|
{"Headset Mic", NULL, "MICBIAS"},
|
|
{"DMICL", NULL, "Int Mic"},
|
|
{"Headphone", NULL, "HPL"},
|
|
{"Headphone", NULL, "HPR"},
|
|
{"Ext Spk", NULL, "SPKL"},
|
|
{"Ext Spk", NULL, "SPKR"},
|
|
{"HiFi Playback", NULL, "ssp2 Tx"},
|
|
{"ssp2 Tx", NULL, "codec_out0"},
|
|
{"ssp2 Tx", NULL, "codec_out1"},
|
|
{"codec_in0", NULL, "ssp2 Rx" },
|
|
{"codec_in1", NULL, "ssp2 Rx" },
|
|
{"ssp2 Rx", NULL, "HiFi Capture"},
|
|
{"Headphone", NULL, "Platform Clock"},
|
|
{"Headset Mic", NULL, "Platform Clock"},
|
|
{"Int Mic", NULL, "Platform Clock"},
|
|
{"Ext Spk", NULL, "Platform Clock"},
|
|
};
|
|
|
|
static const struct snd_kcontrol_new cht_mc_controls[] = {
|
|
SOC_DAPM_PIN_SWITCH("Headphone"),
|
|
SOC_DAPM_PIN_SWITCH("Headset Mic"),
|
|
SOC_DAPM_PIN_SWITCH("Int Mic"),
|
|
SOC_DAPM_PIN_SWITCH("Ext Spk"),
|
|
};
|
|
|
|
static int cht_aif1_hw_params(struct snd_pcm_substream *substream,
|
|
struct snd_pcm_hw_params *params)
|
|
{
|
|
struct snd_soc_pcm_runtime *rtd = substream->private_data;
|
|
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
|
int ret;
|
|
|
|
ret = snd_soc_dai_set_sysclk(codec_dai, M98090_REG_SYSTEM_CLOCK,
|
|
CHT_PLAT_CLK_3_HZ, SND_SOC_CLOCK_IN);
|
|
if (ret < 0) {
|
|
dev_err(rtd->dev, "can't set codec sysclk: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int cht_ti_jack_event(struct notifier_block *nb,
|
|
unsigned long event, void *data)
|
|
{
|
|
struct snd_soc_jack *jack = (struct snd_soc_jack *)data;
|
|
struct snd_soc_dapm_context *dapm = &jack->card->dapm;
|
|
|
|
if (event & SND_JACK_MICROPHONE) {
|
|
snd_soc_dapm_force_enable_pin(dapm, "SHDN");
|
|
snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
|
|
snd_soc_dapm_sync(dapm);
|
|
} else {
|
|
snd_soc_dapm_disable_pin(dapm, "MICBIAS");
|
|
snd_soc_dapm_disable_pin(dapm, "SHDN");
|
|
snd_soc_dapm_sync(dapm);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct notifier_block cht_jack_nb = {
|
|
.notifier_call = cht_ti_jack_event,
|
|
};
|
|
|
|
static struct snd_soc_jack_pin hs_jack_pins[] = {
|
|
{
|
|
.pin = "Headphone",
|
|
.mask = SND_JACK_HEADPHONE,
|
|
},
|
|
{
|
|
.pin = "Headset Mic",
|
|
.mask = SND_JACK_MICROPHONE,
|
|
},
|
|
};
|
|
|
|
static struct snd_soc_jack_gpio hs_jack_gpios[] = {
|
|
{
|
|
.name = "hp",
|
|
.report = SND_JACK_HEADPHONE | SND_JACK_LINEOUT,
|
|
.debounce_time = 200,
|
|
},
|
|
{
|
|
.name = "mic",
|
|
.invert = 1,
|
|
.report = SND_JACK_MICROPHONE,
|
|
.debounce_time = 200,
|
|
},
|
|
};
|
|
|
|
static const struct acpi_gpio_params hp_gpios = { 0, 0, false };
|
|
static const struct acpi_gpio_params mic_gpios = { 1, 0, false };
|
|
|
|
static const struct acpi_gpio_mapping acpi_max98090_gpios[] = {
|
|
{ "hp-gpios", &hp_gpios, 1 },
|
|
{ "mic-gpios", &mic_gpios, 1 },
|
|
{},
|
|
};
|
|
|
|
static int cht_codec_init(struct snd_soc_pcm_runtime *runtime)
|
|
{
|
|
int ret;
|
|
int jack_type;
|
|
struct cht_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);
|
|
struct snd_soc_jack *jack = &ctx->jack;
|
|
|
|
if (ctx->ts3a227e_present) {
|
|
/*
|
|
* The jack has already been created in the
|
|
* cht_max98090_headset_init() function.
|
|
*/
|
|
snd_soc_jack_notifier_register(jack, &cht_jack_nb);
|
|
return 0;
|
|
}
|
|
|
|
jack_type = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE;
|
|
|
|
ret = snd_soc_card_jack_new(runtime->card, "Headset Jack",
|
|
jack_type, jack,
|
|
hs_jack_pins, ARRAY_SIZE(hs_jack_pins));
|
|
if (ret) {
|
|
dev_err(runtime->dev, "Headset Jack creation failed %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = snd_soc_jack_add_gpiods(runtime->card->dev->parent, jack,
|
|
ARRAY_SIZE(hs_jack_gpios),
|
|
hs_jack_gpios);
|
|
if (ret) {
|
|
/*
|
|
* flag error but don't bail if jack detect is broken
|
|
* due to platform issues or bad BIOS/configuration
|
|
*/
|
|
dev_err(runtime->dev,
|
|
"jack detection gpios not added, error %d\n", ret);
|
|
}
|
|
|
|
/* See the comment in snd_cht_mc_probe() */
|
|
if (ctx->quirks & QUIRK_PMC_PLT_CLK_0)
|
|
return 0;
|
|
|
|
/*
|
|
* The firmware might enable the clock at
|
|
* boot (this information may or may not
|
|
* be reflected in the enable clock register).
|
|
* To change the rate we must disable the clock
|
|
* first to cover these cases. Due to common
|
|
* clock framework restrictions that do not allow
|
|
* to disable a clock that has not been enabled,
|
|
* we need to enable the clock first.
|
|
*/
|
|
ret = clk_prepare_enable(ctx->mclk);
|
|
if (!ret)
|
|
clk_disable_unprepare(ctx->mclk);
|
|
|
|
ret = clk_set_rate(ctx->mclk, CHT_PLAT_CLK_3_HZ);
|
|
|
|
if (ret)
|
|
dev_err(runtime->dev, "unable to set MCLK rate\n");
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int cht_codec_fixup(struct snd_soc_pcm_runtime *rtd,
|
|
struct snd_pcm_hw_params *params)
|
|
{
|
|
struct snd_interval *rate = hw_param_interval(params,
|
|
SNDRV_PCM_HW_PARAM_RATE);
|
|
struct snd_interval *channels = hw_param_interval(params,
|
|
SNDRV_PCM_HW_PARAM_CHANNELS);
|
|
int ret = 0;
|
|
unsigned int fmt = 0;
|
|
|
|
ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, 16);
|
|
if (ret < 0) {
|
|
dev_err(rtd->dev, "can't set cpu_dai slot fmt: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
|
|
| SND_SOC_DAIFMT_CBS_CFS;
|
|
|
|
ret = snd_soc_dai_set_fmt(rtd->cpu_dai, fmt);
|
|
if (ret < 0) {
|
|
dev_err(rtd->dev, "can't set cpu_dai set fmt: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/* The DSP will covert the FE rate to 48k, stereo, 24bits */
|
|
rate->min = rate->max = 48000;
|
|
channels->min = channels->max = 2;
|
|
|
|
/* set SSP2 to 16-bit */
|
|
params_set_format(params, SNDRV_PCM_FORMAT_S16_LE);
|
|
return 0;
|
|
}
|
|
|
|
static int cht_aif1_startup(struct snd_pcm_substream *substream)
|
|
{
|
|
return snd_pcm_hw_constraint_single(substream->runtime,
|
|
SNDRV_PCM_HW_PARAM_RATE, 48000);
|
|
}
|
|
|
|
static int cht_max98090_headset_init(struct snd_soc_component *component)
|
|
{
|
|
struct snd_soc_card *card = component->card;
|
|
struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card);
|
|
struct snd_soc_jack *jack = &ctx->jack;
|
|
int jack_type;
|
|
int ret;
|
|
|
|
/*
|
|
* TI supports 4 butons headset detection
|
|
* KEY_MEDIA
|
|
* KEY_VOICECOMMAND
|
|
* KEY_VOLUMEUP
|
|
* KEY_VOLUMEDOWN
|
|
*/
|
|
jack_type = SND_JACK_HEADPHONE | SND_JACK_MICROPHONE |
|
|
SND_JACK_BTN_0 | SND_JACK_BTN_1 |
|
|
SND_JACK_BTN_2 | SND_JACK_BTN_3;
|
|
|
|
ret = snd_soc_card_jack_new(card, "Headset Jack", jack_type,
|
|
jack, NULL, 0);
|
|
if (ret) {
|
|
dev_err(card->dev, "Headset Jack creation failed %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
return ts3a227e_enable_jack_detect(component, jack);
|
|
}
|
|
|
|
static const struct snd_soc_ops cht_aif1_ops = {
|
|
.startup = cht_aif1_startup,
|
|
};
|
|
|
|
static const struct snd_soc_ops cht_be_ssp2_ops = {
|
|
.hw_params = cht_aif1_hw_params,
|
|
};
|
|
|
|
static struct snd_soc_aux_dev cht_max98090_headset_dev = {
|
|
.name = "Headset Chip",
|
|
.init = cht_max98090_headset_init,
|
|
.codec_name = "i2c-104C227E:00",
|
|
};
|
|
|
|
static struct snd_soc_dai_link cht_dailink[] = {
|
|
[MERR_DPCM_AUDIO] = {
|
|
.name = "Audio Port",
|
|
.stream_name = "Audio",
|
|
.cpu_dai_name = "media-cpu-dai",
|
|
.codec_dai_name = "snd-soc-dummy-dai",
|
|
.codec_name = "snd-soc-dummy",
|
|
.platform_name = "sst-mfld-platform",
|
|
.nonatomic = true,
|
|
.dynamic = 1,
|
|
.dpcm_playback = 1,
|
|
.dpcm_capture = 1,
|
|
.ops = &cht_aif1_ops,
|
|
},
|
|
[MERR_DPCM_DEEP_BUFFER] = {
|
|
.name = "Deep-Buffer Audio Port",
|
|
.stream_name = "Deep-Buffer Audio",
|
|
.cpu_dai_name = "deepbuffer-cpu-dai",
|
|
.codec_dai_name = "snd-soc-dummy-dai",
|
|
.codec_name = "snd-soc-dummy",
|
|
.platform_name = "sst-mfld-platform",
|
|
.nonatomic = true,
|
|
.dynamic = 1,
|
|
.dpcm_playback = 1,
|
|
.ops = &cht_aif1_ops,
|
|
},
|
|
/* back ends */
|
|
{
|
|
.name = "SSP2-Codec",
|
|
.id = 0,
|
|
.cpu_dai_name = "ssp2-port",
|
|
.platform_name = "sst-mfld-platform",
|
|
.no_pcm = 1,
|
|
.codec_dai_name = "HiFi",
|
|
.codec_name = "i2c-193C9890:00",
|
|
.dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
|
|
| SND_SOC_DAIFMT_CBS_CFS,
|
|
.init = cht_codec_init,
|
|
.be_hw_params_fixup = cht_codec_fixup,
|
|
.dpcm_playback = 1,
|
|
.dpcm_capture = 1,
|
|
.ops = &cht_be_ssp2_ops,
|
|
},
|
|
};
|
|
|
|
/* SoC card */
|
|
static struct snd_soc_card snd_soc_card_cht = {
|
|
.name = "chtmax98090",
|
|
.owner = THIS_MODULE,
|
|
.dai_link = cht_dailink,
|
|
.num_links = ARRAY_SIZE(cht_dailink),
|
|
.aux_dev = &cht_max98090_headset_dev,
|
|
.num_aux_devs = 1,
|
|
.dapm_widgets = cht_dapm_widgets,
|
|
.num_dapm_widgets = ARRAY_SIZE(cht_dapm_widgets),
|
|
.dapm_routes = cht_audio_map,
|
|
.num_dapm_routes = ARRAY_SIZE(cht_audio_map),
|
|
.controls = cht_mc_controls,
|
|
.num_controls = ARRAY_SIZE(cht_mc_controls),
|
|
};
|
|
|
|
static const struct dmi_system_id cht_max98090_quirk_table[] = {
|
|
{
|
|
/* Clapper model Chromebook */
|
|
.matches = {
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Clapper"),
|
|
},
|
|
.driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
|
|
},
|
|
{
|
|
/* Gnawty model Chromebook (Acer Chromebook CB3-111) */
|
|
.matches = {
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Gnawty"),
|
|
},
|
|
.driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
|
|
},
|
|
{
|
|
/* Swanky model Chromebook (Toshiba Chromebook 2) */
|
|
.matches = {
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Swanky"),
|
|
},
|
|
.driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
|
|
},
|
|
{}
|
|
};
|
|
|
|
static int snd_cht_mc_probe(struct platform_device *pdev)
|
|
{
|
|
const struct dmi_system_id *dmi_id;
|
|
struct device *dev = &pdev->dev;
|
|
int ret_val = 0;
|
|
struct cht_mc_private *drv;
|
|
const char *mclk_name;
|
|
struct snd_soc_acpi_mach *mach;
|
|
const char *platform_name;
|
|
|
|
drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL);
|
|
if (!drv)
|
|
return -ENOMEM;
|
|
|
|
dmi_id = dmi_first_match(cht_max98090_quirk_table);
|
|
if (dmi_id)
|
|
drv->quirks = (unsigned long)dmi_id->driver_data;
|
|
|
|
drv->ts3a227e_present = acpi_dev_found("104C227E");
|
|
if (!drv->ts3a227e_present) {
|
|
/* no need probe TI jack detection chip */
|
|
snd_soc_card_cht.aux_dev = NULL;
|
|
snd_soc_card_cht.num_aux_devs = 0;
|
|
|
|
ret_val = devm_acpi_dev_add_driver_gpios(dev->parent,
|
|
acpi_max98090_gpios);
|
|
if (ret_val)
|
|
dev_dbg(dev, "Unable to add GPIO mapping table\n");
|
|
}
|
|
|
|
/* override plaform name, if required */
|
|
snd_soc_card_cht.dev = &pdev->dev;
|
|
mach = (&pdev->dev)->platform_data;
|
|
platform_name = mach->mach_params.platform;
|
|
|
|
ret_val = snd_soc_fixup_dai_links_platform_name(&snd_soc_card_cht,
|
|
platform_name);
|
|
if (ret_val)
|
|
return ret_val;
|
|
|
|
/* register the soc card */
|
|
snd_soc_card_set_drvdata(&snd_soc_card_cht, drv);
|
|
|
|
if (drv->quirks & QUIRK_PMC_PLT_CLK_0)
|
|
mclk_name = "pmc_plt_clk_0";
|
|
else
|
|
mclk_name = "pmc_plt_clk_3";
|
|
|
|
drv->mclk = devm_clk_get(&pdev->dev, mclk_name);
|
|
if (IS_ERR(drv->mclk)) {
|
|
dev_err(&pdev->dev,
|
|
"Failed to get MCLK from %s: %ld\n",
|
|
mclk_name, PTR_ERR(drv->mclk));
|
|
return PTR_ERR(drv->mclk);
|
|
}
|
|
|
|
/*
|
|
* Boards which have the MAX98090's clk connected to clk_0 do not seem
|
|
* to like it if we muck with the clock. If we disable the clock when
|
|
* it is unused we get "max98090 i2c-193C9890:00: PLL unlocked" errors
|
|
* and the PLL never seems to lock again.
|
|
* So for these boards we enable it here once and leave it at that.
|
|
*/
|
|
if (drv->quirks & QUIRK_PMC_PLT_CLK_0) {
|
|
ret_val = clk_prepare_enable(drv->mclk);
|
|
if (ret_val < 0) {
|
|
dev_err(&pdev->dev, "MCLK enable error: %d\n", ret_val);
|
|
return ret_val;
|
|
}
|
|
}
|
|
|
|
ret_val = devm_snd_soc_register_card(&pdev->dev, &snd_soc_card_cht);
|
|
if (ret_val) {
|
|
dev_err(&pdev->dev,
|
|
"snd_soc_register_card failed %d\n", ret_val);
|
|
return ret_val;
|
|
}
|
|
platform_set_drvdata(pdev, &snd_soc_card_cht);
|
|
return ret_val;
|
|
}
|
|
|
|
static int snd_cht_mc_remove(struct platform_device *pdev)
|
|
{
|
|
struct snd_soc_card *card = platform_get_drvdata(pdev);
|
|
struct cht_mc_private *ctx = snd_soc_card_get_drvdata(card);
|
|
|
|
if (ctx->quirks & QUIRK_PMC_PLT_CLK_0)
|
|
clk_disable_unprepare(ctx->mclk);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_driver snd_cht_mc_driver = {
|
|
.driver = {
|
|
.name = "cht-bsw-max98090",
|
|
},
|
|
.probe = snd_cht_mc_probe,
|
|
.remove = snd_cht_mc_remove,
|
|
};
|
|
|
|
module_platform_driver(snd_cht_mc_driver)
|
|
|
|
MODULE_DESCRIPTION("ASoC Intel(R) Braswell Machine driver");
|
|
MODULE_AUTHOR("Fang, Yang A <yang.a.fang@intel.com>");
|
|
MODULE_LICENSE("GPL v2");
|
|
MODULE_ALIAS("platform:cht-bsw-max98090");
|