[deliverable/linux.git] / sound / soc / intel / boards / skl_rt286.c

/*
 * Intel Skylake I2S Machine Driver
 *
 * Copyright (C) 2014-2015, Intel Corporation. All rights reserved.
 *
 * Modified from:
 *   Intel Broadwell Wildcatpoint SST Audio
 *
 *   Copyright (C) 2013, Intel Corporation. All rights reserved.
 *
 * 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.
 */

#include <linux/module.h>
#include <linux/platform_device.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/soc.h>
#include <sound/jack.h>
#include <sound/pcm_params.h>
#include "../../codecs/rt286.h"
#include "../../codecs/hdac_hdmi.h"

static struct snd_soc_jack skylake_headset;

struct skl_hdmi_pcm {
	struct list_head head;
	struct snd_soc_dai *codec_dai;
	int device;
};

struct skl_rt286_private {
	struct list_head hdmi_pcm_list;
};

enum {
	SKL_DPCM_AUDIO_PB = 0,
	SKL_DPCM_AUDIO_CP,
	SKL_DPCM_AUDIO_REF_CP,
	SKL_DPCM_AUDIO_DMIC_CP,
	SKL_DPCM_AUDIO_HDMI1_PB,
	SKL_DPCM_AUDIO_HDMI2_PB,
	SKL_DPCM_AUDIO_HDMI3_PB,
};

/* Headset jack detection DAPM pins */
static struct snd_soc_jack_pin skylake_headset_pins[] = {
	{
		.pin = "Mic Jack",
		.mask = SND_JACK_MICROPHONE,
	},
	{
		.pin = "Headphone Jack",
		.mask = SND_JACK_HEADPHONE,
	},
};

static const struct snd_kcontrol_new skylake_controls[] = {
	SOC_DAPM_PIN_SWITCH("Speaker"),
	SOC_DAPM_PIN_SWITCH("Headphone Jack"),
	SOC_DAPM_PIN_SWITCH("Mic Jack"),
};

static const struct snd_soc_dapm_widget skylake_widgets[] = {
	SND_SOC_DAPM_HP("Headphone Jack", NULL),
	SND_SOC_DAPM_SPK("Speaker", NULL),
	SND_SOC_DAPM_MIC("Mic Jack", NULL),
	SND_SOC_DAPM_MIC("DMIC2", NULL),
	SND_SOC_DAPM_MIC("SoC DMIC", NULL),
	SND_SOC_DAPM_SPK("HDMI1", NULL),
	SND_SOC_DAPM_SPK("HDMI2", NULL),
	SND_SOC_DAPM_SPK("HDMI3", NULL),
};

static const struct snd_soc_dapm_route skylake_rt286_map[] = {
	/* speaker */
	{"Speaker", NULL, "SPOR"},
	{"Speaker", NULL, "SPOL"},

	/* HP jack connectors - unknown if we have jack deteck */
	{"Headphone Jack", NULL, "HPO Pin"},

	/* other jacks */
	{"MIC1", NULL, "Mic Jack"},

	/* digital mics */
	{"DMIC1 Pin", NULL, "DMIC2"},
	{"DMic", NULL, "SoC DMIC"},

	{"HDMI1", NULL, "hif5 Output"},
	{"HDMI2", NULL, "hif6 Output"},
	{"HDMI3", NULL, "hif7 Output"},

	/* CODEC BE connections */
	{ "AIF1 Playback", NULL, "ssp0 Tx"},
	{ "ssp0 Tx", NULL, "codec0_out"},
	{ "ssp0 Tx", NULL, "codec1_out"},

	{ "codec0_in", NULL, "ssp0 Rx" },
	{ "codec1_in", NULL, "ssp0 Rx" },
	{ "ssp0 Rx", NULL, "AIF1 Capture" },

	{ "dmic01_hifi", NULL, "DMIC01 Rx" },
	{ "DMIC01 Rx", NULL, "DMIC AIF" },

	{ "hifi3", NULL, "iDisp3 Tx"},
	{ "iDisp3 Tx", NULL, "iDisp3_out"},
	{ "hifi2", NULL, "iDisp2 Tx"},
	{ "iDisp2 Tx", NULL, "iDisp2_out"},
	{ "hifi1", NULL, "iDisp1 Tx"},
	{ "iDisp1 Tx", NULL, "iDisp1_out"},

};

static int skylake_rt286_fe_init(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_soc_dapm_context *dapm;
	struct snd_soc_component *component = rtd->cpu_dai->component;

	dapm = snd_soc_component_get_dapm(component);
	snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");

	return 0;
}

static int skylake_rt286_codec_init(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_soc_codec *codec = rtd->codec;
	int ret;

	ret = snd_soc_card_jack_new(rtd->card, "Headset",
		SND_JACK_HEADSET | SND_JACK_BTN_0,
		&skylake_headset,
		skylake_headset_pins, ARRAY_SIZE(skylake_headset_pins));

	if (ret)
		return ret;

	rt286_mic_detect(codec, &skylake_headset);

	snd_soc_dapm_ignore_suspend(&rtd->card->dapm, "SoC DMIC");

	return 0;
}

static int skylake_hdmi_init(struct snd_soc_pcm_runtime *rtd)
{
	struct skl_rt286_private *ctx = snd_soc_card_get_drvdata(rtd->card);
	struct snd_soc_dai *dai = rtd->codec_dai;
	struct skl_hdmi_pcm *pcm;

	pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
	if (!pcm)
		return -ENOMEM;

	pcm->device = SKL_DPCM_AUDIO_HDMI1_PB + dai->id;
	pcm->codec_dai = dai;

	list_add_tail(&pcm->head, &ctx->hdmi_pcm_list);

	return 0;
}

static unsigned int rates[] = {
	48000,
};

static struct snd_pcm_hw_constraint_list constraints_rates = {
	.count = ARRAY_SIZE(rates),
	.list  = rates,
	.mask = 0,
};

static unsigned int channels[] = {
	2,
};

static struct snd_pcm_hw_constraint_list constraints_channels = {
	.count = ARRAY_SIZE(channels),
	.list = channels,
	.mask = 0,
};

static int skl_fe_startup(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;

	/*
	 * on this platform for PCM device we support,
	 *	48Khz
	 *	stereo
	 *	16 bit audio
	 */

	runtime->hw.channels_max = 2;
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
					   &constraints_channels);

	runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
	snd_pcm_hw_constraint_msbits(runtime, 0, 16, 16);

	snd_pcm_hw_constraint_list(runtime, 0,
				SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);

	return 0;
}

static const struct snd_soc_ops skylake_rt286_fe_ops = {
	.startup = skl_fe_startup,
};

static int skylake_ssp0_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);
	struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);

	/* The output is 48KHz, stereo, 16bits */
	rate->min = rate->max = 48000;
	channels->min = channels->max = 2;

	/* set SSP0 to 24 bit */
	snd_mask_none(fmt);
	snd_mask_set(fmt, SNDRV_PCM_FORMAT_S24_LE);
	return 0;
}

static int skylake_rt286_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, RT286_SCLK_S_PLL, 24000000,
		SND_SOC_CLOCK_IN);
	if (ret < 0)
		dev_err(rtd->dev, "set codec sysclk failed: %d\n", ret);

	return ret;
}

static struct snd_soc_ops skylake_rt286_ops = {
	.hw_params = skylake_rt286_hw_params,
};

static int skylake_dmic_fixup(struct snd_soc_pcm_runtime *rtd,
				struct snd_pcm_hw_params *params)
{
	struct snd_interval *channels = hw_param_interval(params,
						SNDRV_PCM_HW_PARAM_CHANNELS);
	if (params_channels(params) == 2)
		channels->min = channels->max = 2;
	else
		channels->min = channels->max = 4;

	return 0;
}

static unsigned int channels_dmic[] = {
	2, 4,
};

static struct snd_pcm_hw_constraint_list constraints_dmic_channels = {
	.count = ARRAY_SIZE(channels_dmic),
	.list = channels_dmic,
	.mask = 0,
};

static int skylake_dmic_startup(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;

	runtime->hw.channels_max = 4;
	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
					   &constraints_dmic_channels);

	return snd_pcm_hw_constraint_list(substream->runtime, 0,
			SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
}

static struct snd_soc_ops skylake_dmic_ops = {
	.startup = skylake_dmic_startup,
};

/* skylake digital audio interface glue - connects codec <--> CPU */
static struct snd_soc_dai_link skylake_rt286_dais[] = {
	/* Front End DAI links */
	[SKL_DPCM_AUDIO_PB] = {
		.name = "Skl Audio Port",
		.stream_name = "Audio",
		.cpu_dai_name = "System Pin",
		.platform_name = "0000:00:1f.3",
		.nonatomic = 1,
		.dynamic = 1,
		.codec_name = "snd-soc-dummy",
		.codec_dai_name = "snd-soc-dummy-dai",
		.init = skylake_rt286_fe_init,
		.trigger = {
			SND_SOC_DPCM_TRIGGER_POST,
			SND_SOC_DPCM_TRIGGER_POST
		},
		.dpcm_playback = 1,
		.ops = &skylake_rt286_fe_ops,
	},
	[SKL_DPCM_AUDIO_CP] = {
		.name = "Skl Audio Capture Port",
		.stream_name = "Audio Record",
		.cpu_dai_name = "System Pin",
		.platform_name = "0000:00:1f.3",
		.nonatomic = 1,
		.dynamic = 1,
		.codec_name = "snd-soc-dummy",
		.codec_dai_name = "snd-soc-dummy-dai",
		.trigger = {
			SND_SOC_DPCM_TRIGGER_POST,
			SND_SOC_DPCM_TRIGGER_POST
		},
		.dpcm_capture = 1,
		.ops = &skylake_rt286_fe_ops,
	},
	[SKL_DPCM_AUDIO_REF_CP] = {
		.name = "Skl Audio Reference cap",
		.stream_name = "refcap",
		.cpu_dai_name = "Reference Pin",
		.codec_name = "snd-soc-dummy",
		.codec_dai_name = "snd-soc-dummy-dai",
		.platform_name = "0000:00:1f.3",
		.init = NULL,
		.dpcm_capture = 1,
		.nonatomic = 1,
		.dynamic = 1,
	},
	[SKL_DPCM_AUDIO_DMIC_CP] = {
		.name = "Skl Audio DMIC cap",
		.stream_name = "dmiccap",
		.cpu_dai_name = "DMIC Pin",
		.codec_name = "snd-soc-dummy",
		.codec_dai_name = "snd-soc-dummy-dai",
		.platform_name = "0000:00:1f.3",
		.init = NULL,
		.dpcm_capture = 1,
		.nonatomic = 1,
		.dynamic = 1,
		.ops = &skylake_dmic_ops,
	},
	[SKL_DPCM_AUDIO_HDMI1_PB] = {
		.name = "Skl HDMI Port1",
		.stream_name = "Hdmi1",
		.cpu_dai_name = "HDMI1 Pin",
		.codec_name = "snd-soc-dummy",
		.codec_dai_name = "snd-soc-dummy-dai",
		.platform_name = "0000:00:1f.3",
		.dpcm_playback = 1,
		.init = NULL,
		.nonatomic = 1,
		.dynamic = 1,
	},
	[SKL_DPCM_AUDIO_HDMI2_PB] = {
		.name = "Skl HDMI Port2",
		.stream_name = "Hdmi2",
		.cpu_dai_name = "HDMI2 Pin",
		.codec_name = "snd-soc-dummy",
		.codec_dai_name = "snd-soc-dummy-dai",
		.platform_name = "0000:00:1f.3",
		.dpcm_playback = 1,
		.init = NULL,
		.nonatomic = 1,
		.dynamic = 1,
	},
	[SKL_DPCM_AUDIO_HDMI3_PB] = {
		.name = "Skl HDMI Port3",
		.stream_name = "Hdmi3",
		.cpu_dai_name = "HDMI3 Pin",
		.codec_name = "snd-soc-dummy",
		.codec_dai_name = "snd-soc-dummy-dai",
		.platform_name = "0000:00:1f.3",
		.dpcm_playback = 1,
		.init = NULL,
		.nonatomic = 1,
		.dynamic = 1,
	},

	/* Back End DAI links */
	{
		/* SSP0 - Codec */
		.name = "SSP0-Codec",
		.id = 0,
		.cpu_dai_name = "SSP0 Pin",
		.platform_name = "0000:00:1f.3",
		.no_pcm = 1,
		.codec_name = "i2c-INT343A:00",
		.codec_dai_name = "rt286-aif1",
		.init = skylake_rt286_codec_init,
		.dai_fmt = SND_SOC_DAIFMT_I2S |
			SND_SOC_DAIFMT_NB_NF |
			SND_SOC_DAIFMT_CBS_CFS,
		.ignore_pmdown_time = 1,
		.be_hw_params_fixup = skylake_ssp0_fixup,
		.ops = &skylake_rt286_ops,
		.dpcm_playback = 1,
		.dpcm_capture = 1,
	},
	{
		.name = "dmic01",
		.id = 1,
		.cpu_dai_name = "DMIC01 Pin",
		.codec_name = "dmic-codec",
		.codec_dai_name = "dmic-hifi",
		.platform_name = "0000:00:1f.3",
		.be_hw_params_fixup = skylake_dmic_fixup,
		.ignore_suspend = 1,
		.dpcm_capture = 1,
		.no_pcm = 1,
	},
	{
		.name = "iDisp1",
		.id = 2,
		.cpu_dai_name = "iDisp1 Pin",
		.codec_name = "ehdaudio0D2",
		.codec_dai_name = "intel-hdmi-hifi1",
		.platform_name = "0000:00:1f.3",
		.init = skylake_hdmi_init,
		.dpcm_playback = 1,
		.no_pcm = 1,
	},
	{
		.name = "iDisp2",
		.id = 3,
		.cpu_dai_name = "iDisp2 Pin",
		.codec_name = "ehdaudio0D2",
		.codec_dai_name = "intel-hdmi-hifi2",
		.platform_name = "0000:00:1f.3",
		.init = skylake_hdmi_init,
		.dpcm_playback = 1,
		.no_pcm = 1,
	},
	{
		.name = "iDisp3",
		.id = 4,
		.cpu_dai_name = "iDisp3 Pin",
		.codec_name = "ehdaudio0D2",
		.codec_dai_name = "intel-hdmi-hifi3",
		.platform_name = "0000:00:1f.3",
		.init = skylake_hdmi_init,
		.dpcm_playback = 1,
		.no_pcm = 1,
	},
};

static int skylake_card_late_probe(struct snd_soc_card *card)
{
	struct skl_rt286_private *ctx = snd_soc_card_get_drvdata(card);
	struct skl_hdmi_pcm *pcm;
	int err;

	list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) {
		err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device);
		if (err < 0)
			return err;
	}

	return 0;
}

/* skylake audio machine driver for SPT + RT286S */
static struct snd_soc_card skylake_rt286 = {
	.name = "skylake-rt286",
	.owner = THIS_MODULE,
	.dai_link = skylake_rt286_dais,
	.num_links = ARRAY_SIZE(skylake_rt286_dais),
	.controls = skylake_controls,
	.num_controls = ARRAY_SIZE(skylake_controls),
	.dapm_widgets = skylake_widgets,
	.num_dapm_widgets = ARRAY_SIZE(skylake_widgets),
	.dapm_routes = skylake_rt286_map,
	.num_dapm_routes = ARRAY_SIZE(skylake_rt286_map),
	.fully_routed = true,
	.late_probe = skylake_card_late_probe,
};

static int skylake_audio_probe(struct platform_device *pdev)
{
	struct skl_rt286_private *ctx;

	ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_ATOMIC);
	if (!ctx)
		return -ENOMEM;

	INIT_LIST_HEAD(&ctx->hdmi_pcm_list);

	skylake_rt286.dev = &pdev->dev;
	snd_soc_card_set_drvdata(&skylake_rt286, ctx);

	return devm_snd_soc_register_card(&pdev->dev, &skylake_rt286);
}

static struct platform_driver skylake_audio = {
	.probe = skylake_audio_probe,
	.driver = {
		.name = "skl_alc286s_i2s",
		.pm = &snd_soc_pm_ops,
	},
};

module_platform_driver(skylake_audio)

/* Module information */
MODULE_AUTHOR("Omair Mohammed Abdullah <omair.m.abdullah@intel.com>");
MODULE_DESCRIPTION("Intel SST Audio for Skylake");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:skl_alc286s_i2s");
Commit	Line	Data
624729fd OA	1	/*
	2	* Intel Skylake I2S Machine Driver
	3	*
	4	* Copyright (C) 2014-2015, Intel Corporation. All rights reserved.
	5	*
	6	* Modified from:
	7	* Intel Broadwell Wildcatpoint SST Audio
	8	*
	9	* Copyright (C) 2013, Intel Corporation. All rights reserved.
	10	*
	11	* This program is free software; you can redistribute it and/or
	12	* modify it under the terms of the GNU General Public License version
	13	* 2 as published by the Free Software Foundation.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*/
	20
	21	#include <linux/module.h>
	22	#include <linux/platform_device.h>
	23	#include <sound/core.h>
	24	#include <sound/pcm.h>
	25	#include <sound/soc.h>
	26	#include <sound/jack.h>
	27	#include <sound/pcm_params.h>
	28	#include "../../codecs/rt286.h"
23905cd1	29	#include "../../codecs/hdac_hdmi.h"
624729fd OA	30
624729fd OA	31	static struct snd_soc_jack skylake_headset;
23905cd1	32
1a10612f SP	33	struct skl_hdmi_pcm {
	34	struct list_head head;
	35	struct snd_soc_dai *codec_dai;
	36	int device;
	37	};
	38
	39	struct skl_rt286_private {
	40	struct list_head hdmi_pcm_list;
	41	};
	42
23905cd1 JK	43	enum {
	44	SKL_DPCM_AUDIO_PB = 0,
	45	SKL_DPCM_AUDIO_CP,
	46	SKL_DPCM_AUDIO_REF_CP,
	47	SKL_DPCM_AUDIO_DMIC_CP,
	48	SKL_DPCM_AUDIO_HDMI1_PB,
	49	SKL_DPCM_AUDIO_HDMI2_PB,
	50	SKL_DPCM_AUDIO_HDMI3_PB,
	51	};
	52
624729fd OA	53	/* Headset jack detection DAPM pins */
	54	static struct snd_soc_jack_pin skylake_headset_pins[] = {
	55	{
	56	.pin = "Mic Jack",
	57	.mask = SND_JACK_MICROPHONE,
	58	},
	59	{
	60	.pin = "Headphone Jack",
	61	.mask = SND_JACK_HEADPHONE,
	62	},
	63	};
	64
	65	static const struct snd_kcontrol_new skylake_controls[] = {
	66	SOC_DAPM_PIN_SWITCH("Speaker"),
	67	SOC_DAPM_PIN_SWITCH("Headphone Jack"),
	68	SOC_DAPM_PIN_SWITCH("Mic Jack"),
	69	};
	70
	71	static const struct snd_soc_dapm_widget skylake_widgets[] = {
	72	SND_SOC_DAPM_HP("Headphone Jack", NULL),
	73	SND_SOC_DAPM_SPK("Speaker", NULL),
	74	SND_SOC_DAPM_MIC("Mic Jack", NULL),
	75	SND_SOC_DAPM_MIC("DMIC2", NULL),
	76	SND_SOC_DAPM_MIC("SoC DMIC", NULL),
23905cd1 JK	77	SND_SOC_DAPM_SPK("HDMI1", NULL),
	78	SND_SOC_DAPM_SPK("HDMI2", NULL),
	79	SND_SOC_DAPM_SPK("HDMI3", NULL),
624729fd OA	80	};
	81
	82	static const struct snd_soc_dapm_route skylake_rt286_map[] = {
	83	/* speaker */
	84	{"Speaker", NULL, "SPOR"},
	85	{"Speaker", NULL, "SPOL"},
	86
	87	/* HP jack connectors - unknown if we have jack deteck */
	88	{"Headphone Jack", NULL, "HPO Pin"},
	89
	90	/* other jacks */
	91	{"MIC1", NULL, "Mic Jack"},
	92
	93	/* digital mics */
	94	{"DMIC1 Pin", NULL, "DMIC2"},
820f339f	95	{"DMic", NULL, "SoC DMIC"},
624729fd	96
23905cd1 JK	97	{"HDMI1", NULL, "hif5 Output"},
	98	{"HDMI2", NULL, "hif6 Output"},
	99	{"HDMI3", NULL, "hif7 Output"},
	100
624729fd OA	101	/* CODEC BE connections */
	102	{ "AIF1 Playback", NULL, "ssp0 Tx"},
	103	{ "ssp0 Tx", NULL, "codec0_out"},
	104	{ "ssp0 Tx", NULL, "codec1_out"},
	105
	106	{ "codec0_in", NULL, "ssp0 Rx" },
	107	{ "codec1_in", NULL, "ssp0 Rx" },
	108	{ "ssp0 Rx", NULL, "AIF1 Capture" },
	109
	110	{ "dmic01_hifi", NULL, "DMIC01 Rx" },
820f339f	111	{ "DMIC01 Rx", NULL, "DMIC AIF" },
624729fd	112
23905cd1 JK	113	{ "hifi3", NULL, "iDisp3 Tx"},
	114	{ "iDisp3 Tx", NULL, "iDisp3_out"},
	115	{ "hifi2", NULL, "iDisp2 Tx"},
	116	{ "iDisp2 Tx", NULL, "iDisp2_out"},
	117	{ "hifi1", NULL, "iDisp1 Tx"},
	118	{ "iDisp1 Tx", NULL, "iDisp1_out"},
624729fd OA	119
	120	};
	121
9ec2053b PD	122	static int skylake_rt286_fe_init(struct snd_soc_pcm_runtime *rtd)
	123	{
	124	struct snd_soc_dapm_context *dapm;
	125	struct snd_soc_component *component = rtd->cpu_dai->component;
	126
	127	dapm = snd_soc_component_get_dapm(component);
	128	snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
	129
	130	return 0;
	131	}
	132
624729fd OA	133	static int skylake_rt286_codec_init(struct snd_soc_pcm_runtime *rtd)
	134	{
	135	struct snd_soc_codec *codec = rtd->codec;
	136	int ret;
	137
	138	ret = snd_soc_card_jack_new(rtd->card, "Headset",
	139	SND_JACK_HEADSET \| SND_JACK_BTN_0,
	140	&skylake_headset,
	141	skylake_headset_pins, ARRAY_SIZE(skylake_headset_pins));
	142
	143	if (ret)
	144	return ret;
	145
	146	rt286_mic_detect(codec, &skylake_headset);
	147
9ec2053b	148	snd_soc_dapm_ignore_suspend(&rtd->card->dapm, "SoC DMIC");
9ec2053b	149
624729fd OA	150	return 0;
	151	}
	152
23905cd1 JK	153	static int skylake_hdmi_init(struct snd_soc_pcm_runtime *rtd)
23905cd1 JK	154	{
1a10612f	155	struct skl_rt286_private *ctx = snd_soc_card_get_drvdata(rtd->card);
23905cd1	156	struct snd_soc_dai *dai = rtd->codec_dai;
1a10612f SP	157	struct skl_hdmi_pcm *pcm;
	158
	159	pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
	160	if (!pcm)
	161	return -ENOMEM;
23905cd1	162
1a10612f SP	163	pcm->device = SKL_DPCM_AUDIO_HDMI1_PB + dai->id;
	164	pcm->codec_dai = dai;
	165
	166	list_add_tail(&pcm->head, &ctx->hdmi_pcm_list);
	167
	168	return 0;
23905cd1 JK	169	}
23905cd1 JK	170
5eab6ab9 VK	171	static unsigned int rates[] = {
	172	48000,
	173	};
	174
	175	static struct snd_pcm_hw_constraint_list constraints_rates = {
	176	.count = ARRAY_SIZE(rates),
	177	.list = rates,
	178	.mask = 0,
	179	};
	180
	181	static unsigned int channels[] = {
	182	2,
	183	};
	184
	185	static struct snd_pcm_hw_constraint_list constraints_channels = {
	186	.count = ARRAY_SIZE(channels),
	187	.list = channels,
	188	.mask = 0,
	189	};
	190
	191	static int skl_fe_startup(struct snd_pcm_substream *substream)
	192	{
	193	struct snd_pcm_runtime *runtime = substream->runtime;
	194
	195	/*
	196	* on this platform for PCM device we support,
	197	* 48Khz
	198	* stereo
	199	* 16 bit audio
	200	*/
	201
	202	runtime->hw.channels_max = 2;
	203	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
	204	&constraints_channels);
	205
	206	runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
	207	snd_pcm_hw_constraint_msbits(runtime, 0, 16, 16);
	208
	209	snd_pcm_hw_constraint_list(runtime, 0,
	210	SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
	211
	212	return 0;
	213	}
	214
	215	static const struct snd_soc_ops skylake_rt286_fe_ops = {
	216	.startup = skl_fe_startup,
	217	};
624729fd OA	218
	219	static int skylake_ssp0_fixup(struct snd_soc_pcm_runtime *rtd,
	220	struct snd_pcm_hw_params *params)
	221	{
	222	struct snd_interval *rate = hw_param_interval(params,
	223	SNDRV_PCM_HW_PARAM_RATE);
	224	struct snd_interval *channels = hw_param_interval(params,
	225	SNDRV_PCM_HW_PARAM_CHANNELS);
677165f7	226	struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
624729fd OA	227
	228	/* The output is 48KHz, stereo, 16bits */
	229	rate->min = rate->max = 48000;
	230	channels->min = channels->max = 2;
624729fd	231
677165f7 JK	232	/* set SSP0 to 24 bit */
	233	snd_mask_none(fmt);
	234	snd_mask_set(fmt, SNDRV_PCM_FORMAT_S24_LE);
624729fd OA	235	return 0;
	236	}
	237
	238	static int skylake_rt286_hw_params(struct snd_pcm_substream *substream,
	239	struct snd_pcm_hw_params *params)
	240	{
	241	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	242	struct snd_soc_dai *codec_dai = rtd->codec_dai;
	243	int ret;
	244
	245	ret = snd_soc_dai_set_sysclk(codec_dai, RT286_SCLK_S_PLL, 24000000,
	246	SND_SOC_CLOCK_IN);
	247	if (ret < 0)
	248	dev_err(rtd->dev, "set codec sysclk failed: %d\n", ret);
	249
	250	return ret;
	251	}
	252
	253	static struct snd_soc_ops skylake_rt286_ops = {
	254	.hw_params = skylake_rt286_hw_params,
	255	};
	256
4386b767 JK	257	static int skylake_dmic_fixup(struct snd_soc_pcm_runtime *rtd,
	258	struct snd_pcm_hw_params *params)
	259	{
	260	struct snd_interval *channels = hw_param_interval(params,
	261	SNDRV_PCM_HW_PARAM_CHANNELS);
6e3ffa00 JK	262	if (params_channels(params) == 2)
	263	channels->min = channels->max = 2;
	264	else
	265	channels->min = channels->max = 4;
4386b767 JK	266
	267	return 0;
	268	}
	269
	270	static unsigned int channels_dmic[] = {
	271	2, 4,
	272	};
	273
	274	static struct snd_pcm_hw_constraint_list constraints_dmic_channels = {
	275	.count = ARRAY_SIZE(channels_dmic),
	276	.list = channels_dmic,
	277	.mask = 0,
	278	};
	279
	280	static int skylake_dmic_startup(struct snd_pcm_substream *substream)
	281	{
	282	struct snd_pcm_runtime *runtime = substream->runtime;
	283
	284	runtime->hw.channels_max = 4;
	285	snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
	286	&constraints_dmic_channels);
	287
	288	return snd_pcm_hw_constraint_list(substream->runtime, 0,
	289	SNDRV_PCM_HW_PARAM_RATE, &constraints_rates);
	290	}
	291
	292	static struct snd_soc_ops skylake_dmic_ops = {
	293	.startup = skylake_dmic_startup,
	294	};
	295
624729fd OA	296	/* skylake digital audio interface glue - connects codec <--> CPU */
	297	static struct snd_soc_dai_link skylake_rt286_dais[] = {
	298	/* Front End DAI links */
23905cd1	299	[SKL_DPCM_AUDIO_PB] = {
624729fd OA	300	.name = "Skl Audio Port",
	301	.stream_name = "Audio",
	302	.cpu_dai_name = "System Pin",
	303	.platform_name = "0000:00:1f.3",
	304	.nonatomic = 1,
	305	.dynamic = 1,
	306	.codec_name = "snd-soc-dummy",
	307	.codec_dai_name = "snd-soc-dummy-dai",
9ec2053b	308	.init = skylake_rt286_fe_init,
624729fd OA	309	.trigger = {
	310	SND_SOC_DPCM_TRIGGER_POST,
	311	SND_SOC_DPCM_TRIGGER_POST
	312	},
	313	.dpcm_playback = 1,
5eab6ab9	314	.ops = &skylake_rt286_fe_ops,
624729fd	315	},
23905cd1	316	[SKL_DPCM_AUDIO_CP] = {
624729fd OA	317	.name = "Skl Audio Capture Port",
	318	.stream_name = "Audio Record",
	319	.cpu_dai_name = "System Pin",
	320	.platform_name = "0000:00:1f.3",
	321	.nonatomic = 1,
	322	.dynamic = 1,
	323	.codec_name = "snd-soc-dummy",
	324	.codec_dai_name = "snd-soc-dummy-dai",
	325	.trigger = {
	326	SND_SOC_DPCM_TRIGGER_POST,
	327	SND_SOC_DPCM_TRIGGER_POST
	328	},
	329	.dpcm_capture = 1,
5eab6ab9	330	.ops = &skylake_rt286_fe_ops,
624729fd	331	},
23905cd1	332	[SKL_DPCM_AUDIO_REF_CP] = {
624729fd OA	333	.name = "Skl Audio Reference cap",
	334	.stream_name = "refcap",
	335	.cpu_dai_name = "Reference Pin",
	336	.codec_name = "snd-soc-dummy",
	337	.codec_dai_name = "snd-soc-dummy-dai",
	338	.platform_name = "0000:00:1f.3",
	339	.init = NULL,
	340	.dpcm_capture = 1,
624729fd OA	341	.nonatomic = 1,
	342	.dynamic = 1,
	343	},
23905cd1	344	[SKL_DPCM_AUDIO_DMIC_CP] = {
4386b767 JK	345	.name = "Skl Audio DMIC cap",
	346	.stream_name = "dmiccap",
	347	.cpu_dai_name = "DMIC Pin",
	348	.codec_name = "snd-soc-dummy",
	349	.codec_dai_name = "snd-soc-dummy-dai",
	350	.platform_name = "0000:00:1f.3",
	351	.init = NULL,
	352	.dpcm_capture = 1,
4386b767 JK	353	.nonatomic = 1,
	354	.dynamic = 1,
	355	.ops = &skylake_dmic_ops,
	356	},
23905cd1 JK	357	[SKL_DPCM_AUDIO_HDMI1_PB] = {
	358	.name = "Skl HDMI Port1",
	359	.stream_name = "Hdmi1",
	360	.cpu_dai_name = "HDMI1 Pin",
	361	.codec_name = "snd-soc-dummy",
	362	.codec_dai_name = "snd-soc-dummy-dai",
	363	.platform_name = "0000:00:1f.3",
	364	.dpcm_playback = 1,
	365	.init = NULL,
	366	.nonatomic = 1,
	367	.dynamic = 1,
	368	},
	369	[SKL_DPCM_AUDIO_HDMI2_PB] = {
	370	.name = "Skl HDMI Port2",
	371	.stream_name = "Hdmi2",
	372	.cpu_dai_name = "HDMI2 Pin",
	373	.codec_name = "snd-soc-dummy",
	374	.codec_dai_name = "snd-soc-dummy-dai",
	375	.platform_name = "0000:00:1f.3",
	376	.dpcm_playback = 1,
	377	.init = NULL,
	378	.nonatomic = 1,
	379	.dynamic = 1,
	380	},
	381	[SKL_DPCM_AUDIO_HDMI3_PB] = {
	382	.name = "Skl HDMI Port3",
	383	.stream_name = "Hdmi3",
	384	.cpu_dai_name = "HDMI3 Pin",
	385	.codec_name = "snd-soc-dummy",
	386	.codec_dai_name = "snd-soc-dummy-dai",
	387	.platform_name = "0000:00:1f.3",
	388	.dpcm_playback = 1,
	389	.init = NULL,
	390	.nonatomic = 1,
	391	.dynamic = 1,
	392	},
624729fd OA	393
	394	/* Back End DAI links */
	395	{
	396	/* SSP0 - Codec */
	397	.name = "SSP0-Codec",
2f0ad491	398	.id = 0,
624729fd OA	399	.cpu_dai_name = "SSP0 Pin",
	400	.platform_name = "0000:00:1f.3",
	401	.no_pcm = 1,
	402	.codec_name = "i2c-INT343A:00",
	403	.codec_dai_name = "rt286-aif1",
	404	.init = skylake_rt286_codec_init,
	405	.dai_fmt = SND_SOC_DAIFMT_I2S \|
	406	SND_SOC_DAIFMT_NB_NF \|
	407	SND_SOC_DAIFMT_CBS_CFS,
624729fd OA	408	.ignore_pmdown_time = 1,
	409	.be_hw_params_fixup = skylake_ssp0_fixup,
	410	.ops = &skylake_rt286_ops,
	411	.dpcm_playback = 1,
	412	.dpcm_capture = 1,
	413	},
	414	{
	415	.name = "dmic01",
2f0ad491	416	.id = 1,
624729fd OA	417	.cpu_dai_name = "DMIC01 Pin",
	418	.codec_name = "dmic-codec",
	419	.codec_dai_name = "dmic-hifi",
	420	.platform_name = "0000:00:1f.3",
4386b767	421	.be_hw_params_fixup = skylake_dmic_fixup,
624729fd OA	422	.ignore_suspend = 1,
	423	.dpcm_capture = 1,
	424	.no_pcm = 1,
	425	},
23905cd1 JK	426	{
23905cd1 JK	427	.name = "iDisp1",
2f0ad491	428	.id = 2,
23905cd1 JK	429	.cpu_dai_name = "iDisp1 Pin",
	430	.codec_name = "ehdaudio0D2",
	431	.codec_dai_name = "intel-hdmi-hifi1",
	432	.platform_name = "0000:00:1f.3",
	433	.init = skylake_hdmi_init,
	434	.dpcm_playback = 1,
	435	.no_pcm = 1,
	436	},
	437	{
	438	.name = "iDisp2",
2f0ad491	439	.id = 3,
23905cd1 JK	440	.cpu_dai_name = "iDisp2 Pin",
	441	.codec_name = "ehdaudio0D2",
	442	.codec_dai_name = "intel-hdmi-hifi2",
	443	.platform_name = "0000:00:1f.3",
	444	.init = skylake_hdmi_init,
	445	.dpcm_playback = 1,
	446	.no_pcm = 1,
	447	},
	448	{
	449	.name = "iDisp3",
2f0ad491	450	.id = 4,
23905cd1 JK	451	.cpu_dai_name = "iDisp3 Pin",
	452	.codec_name = "ehdaudio0D2",
	453	.codec_dai_name = "intel-hdmi-hifi3",
	454	.platform_name = "0000:00:1f.3",
	455	.init = skylake_hdmi_init,
	456	.dpcm_playback = 1,
	457	.no_pcm = 1,
	458	},
624729fd OA	459	};
624729fd OA	460
1a10612f SP	461	static int skylake_card_late_probe(struct snd_soc_card *card)
	462	{
	463	struct skl_rt286_private *ctx = snd_soc_card_get_drvdata(card);
	464	struct skl_hdmi_pcm *pcm;
	465	int err;
	466
	467	list_for_each_entry(pcm, &ctx->hdmi_pcm_list, head) {
	468	err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device);
	469	if (err < 0)
	470	return err;
	471	}
	472
	473	return 0;
	474	}
	475
624729fd OA	476	/* skylake audio machine driver for SPT + RT286S */
	477	static struct snd_soc_card skylake_rt286 = {
	478	.name = "skylake-rt286",
	479	.owner = THIS_MODULE,
	480	.dai_link = skylake_rt286_dais,
	481	.num_links = ARRAY_SIZE(skylake_rt286_dais),
	482	.controls = skylake_controls,
	483	.num_controls = ARRAY_SIZE(skylake_controls),
	484	.dapm_widgets = skylake_widgets,
	485	.num_dapm_widgets = ARRAY_SIZE(skylake_widgets),
	486	.dapm_routes = skylake_rt286_map,
	487	.num_dapm_routes = ARRAY_SIZE(skylake_rt286_map),
	488	.fully_routed = true,
1a10612f	489	.late_probe = skylake_card_late_probe,
624729fd OA	490	};
	491
	492	static int skylake_audio_probe(struct platform_device *pdev)
	493	{
1a10612f SP	494	struct skl_rt286_private *ctx;
	495
	496	ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_ATOMIC);
	497	if (!ctx)
	498	return -ENOMEM;
	499
	500	INIT_LIST_HEAD(&ctx->hdmi_pcm_list);
	501
624729fd	502	skylake_rt286.dev = &pdev->dev;
1a10612f	503	snd_soc_card_set_drvdata(&skylake_rt286, ctx);
624729fd	504
4901aa06	505	return devm_snd_soc_register_card(&pdev->dev, &skylake_rt286);
624729fd OA	506	}
	507
	508	static struct platform_driver skylake_audio = {
	509	.probe = skylake_audio_probe,
624729fd OA	510	.driver = {
624729fd OA	511	.name = "skl_alc286s_i2s",
314038e4	512	.pm = &snd_soc_pm_ops,
624729fd OA	513	},
	514	};
	515
	516	module_platform_driver(skylake_audio)
	517
	518	/* Module information */
	519	MODULE_AUTHOR("Omair Mohammed Abdullah <omair.m.abdullah@intel.com>");
	520	MODULE_DESCRIPTION("Intel SST Audio for Skylake");
	521	MODULE_LICENSE("GPL v2");
	522	MODULE_ALIAS("platform:skl_alc286s_i2s");