[deliverable/linux.git] / sound / soc / codecs / hdac_hdmi.c

/*
 *  hdac_hdmi.c - ASoc HDA-HDMI codec driver for Intel platforms
 *
 *  Copyright (C) 2014-2015 Intel Corp
 *  Author: Samreen Nilofer <samreen.nilofer@intel.com>
 *	    Subhransu S. Prusty <subhransu.s.prusty@intel.com>
 *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 of the License.
 *
 *  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/init.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/pm_runtime.h>
#include <linux/hdmi.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/hdaudio_ext.h>
#include <sound/hda_i915.h>
#include "../../hda/local.h"

#define AMP_OUT_MUTE		0xb080
#define AMP_OUT_UNMUTE		0xb000
#define PIN_OUT			(AC_PINCTL_OUT_EN)

#define HDA_MAX_CONNECTIONS     32

struct hdac_hdmi_cvt_params {
	unsigned int channels_min;
	unsigned int channels_max;
	u32 rates;
	u64 formats;
	unsigned int maxbps;
};

struct hdac_hdmi_cvt {
	struct list_head head;
	hda_nid_t nid;
	struct hdac_hdmi_cvt_params params;
};

struct hdac_hdmi_pin {
	struct list_head head;
	hda_nid_t nid;
	int num_mux_nids;
	hda_nid_t mux_nids[HDA_MAX_CONNECTIONS];
};

struct hdac_hdmi_dai_pin_map {
	int dai_id;
	struct hdac_hdmi_pin *pin;
	struct hdac_hdmi_cvt *cvt;
};

struct hdac_hdmi_priv {
	struct hdac_hdmi_dai_pin_map dai_map[3];
	struct list_head pin_list;
	struct list_head cvt_list;
	int num_pin;
	int num_cvt;
};

static inline struct hdac_ext_device *to_hda_ext_device(struct device *dev)
{
	struct hdac_device *hdac = dev_to_hdac_dev(dev);

	return to_ehdac_device(hdac);
}

static int hdac_hdmi_setup_stream(struct hdac_ext_device *hdac,
				hda_nid_t cvt_nid, hda_nid_t pin_nid,
				u32 stream_tag, int format)
{
	unsigned int val;

	dev_dbg(&hdac->hdac.dev, "cvt nid %d pnid %d stream %d format 0x%x\n",
			cvt_nid, pin_nid, stream_tag, format);

	val = (stream_tag << 4);

	snd_hdac_codec_write(&hdac->hdac, cvt_nid, 0,
				AC_VERB_SET_CHANNEL_STREAMID, val);
	snd_hdac_codec_write(&hdac->hdac, cvt_nid, 0,
				AC_VERB_SET_STREAM_FORMAT, format);

	return 0;
}

static void
hdac_hdmi_set_dip_index(struct hdac_ext_device *hdac, hda_nid_t pin_nid,
				int packet_index, int byte_index)
{
	int val;

	val = (packet_index << 5) | (byte_index & 0x1f);

	snd_hdac_codec_write(&hdac->hdac, pin_nid, 0,
				AC_VERB_SET_HDMI_DIP_INDEX, val);
}

static int hdac_hdmi_setup_audio_infoframe(struct hdac_ext_device *hdac,
				hda_nid_t cvt_nid, hda_nid_t pin_nid)
{
	uint8_t buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AUDIO_INFOFRAME_SIZE];
	struct hdmi_audio_infoframe frame;
	u8 *dip = (u8 *)&frame;
	int ret;
	int i;

	hdmi_audio_infoframe_init(&frame);

	/* Default stereo for now */
	frame.channels = 2;

	/* setup channel count */
	snd_hdac_codec_write(&hdac->hdac, cvt_nid, 0,
			    AC_VERB_SET_CVT_CHAN_COUNT, frame.channels - 1);

	ret = hdmi_audio_infoframe_pack(&frame, buffer, sizeof(buffer));
	if (ret < 0)
		return ret;

	/* stop infoframe transmission */
	hdac_hdmi_set_dip_index(hdac, pin_nid, 0x0, 0x0);
	snd_hdac_codec_write(&hdac->hdac, pin_nid, 0,
			AC_VERB_SET_HDMI_DIP_XMIT, AC_DIPXMIT_DISABLE);


	/*  Fill infoframe. Index auto-incremented */
	hdac_hdmi_set_dip_index(hdac, pin_nid, 0x0, 0x0);
	for (i = 0; i < sizeof(frame); i++)
		snd_hdac_codec_write(&hdac->hdac, pin_nid, 0,
				AC_VERB_SET_HDMI_DIP_DATA, dip[i]);

	/* Start infoframe */
	hdac_hdmi_set_dip_index(hdac, pin_nid, 0x0, 0x0);
	snd_hdac_codec_write(&hdac->hdac, pin_nid, 0,
			AC_VERB_SET_HDMI_DIP_XMIT, AC_DIPXMIT_BEST);

	return 0;
}

static void hdac_hdmi_set_power_state(struct hdac_ext_device *edev,
		struct hdac_hdmi_dai_pin_map *dai_map, unsigned int pwr_state)
{
	/* Power up pin widget */
	if (!snd_hdac_check_power_state(&edev->hdac, dai_map->pin->nid,
						pwr_state))
		snd_hdac_codec_write(&edev->hdac, dai_map->pin->nid, 0,
			AC_VERB_SET_POWER_STATE, pwr_state);

	/* Power up converter */
	if (!snd_hdac_check_power_state(&edev->hdac, dai_map->cvt->nid,
						pwr_state))
		snd_hdac_codec_write(&edev->hdac, dai_map->cvt->nid, 0,
			AC_VERB_SET_POWER_STATE, pwr_state);
}

static int hdac_hdmi_playback_prepare(struct snd_pcm_substream *substream,
				struct snd_soc_dai *dai)
{
	struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai);
	struct hdac_hdmi_priv *hdmi = hdac->private_data;
	struct hdac_hdmi_dai_pin_map *dai_map;
	struct hdac_ext_dma_params *dd;
	int ret;

	if (dai->id > 0) {
		dev_err(&hdac->hdac.dev, "Only one dai supported as of now\n");
		return -ENODEV;
	}

	dai_map = &hdmi->dai_map[dai->id];

	dd = (struct hdac_ext_dma_params *)snd_soc_dai_get_dma_data(dai, substream);
	dev_dbg(&hdac->hdac.dev, "stream tag from cpu dai %d format in cvt 0x%x\n",
			dd->stream_tag,	dd->format);

	ret = hdac_hdmi_setup_audio_infoframe(hdac, dai_map->cvt->nid,
						dai_map->pin->nid);
	if (ret < 0)
		return ret;

	return hdac_hdmi_setup_stream(hdac, dai_map->cvt->nid,
			dai_map->pin->nid, dd->stream_tag, dd->format);
}

static int hdac_hdmi_set_hw_params(struct snd_pcm_substream *substream,
	struct snd_pcm_hw_params *hparams, struct snd_soc_dai *dai)
{
	struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai);
	struct hdac_ext_dma_params *dd;

	if (dai->id > 0) {
		dev_err(&hdac->hdac.dev, "Only one dai supported as of now\n");
		return -ENODEV;
	}

	dd = kzalloc(sizeof(*dd), GFP_KERNEL);
	if (!dd)
		return -ENOMEM;
	dd->format = snd_hdac_calc_stream_format(params_rate(hparams),
			params_channels(hparams), params_format(hparams),
			24, 0);

	snd_soc_dai_set_dma_data(dai, substream, (void *)dd);

	return 0;
}

static int hdac_hdmi_playback_cleanup(struct snd_pcm_substream *substream,
		struct snd_soc_dai *dai)
{
	struct hdac_ext_device *edev = snd_soc_dai_get_drvdata(dai);
	struct hdac_ext_dma_params *dd;
	struct hdac_hdmi_priv *hdmi = edev->private_data;
	struct hdac_hdmi_dai_pin_map *dai_map;

	dai_map = &hdmi->dai_map[dai->id];

	snd_hdac_codec_write(&edev->hdac, dai_map->cvt->nid, 0,
				AC_VERB_SET_CHANNEL_STREAMID, 0);
	snd_hdac_codec_write(&edev->hdac, dai_map->cvt->nid, 0,
				AC_VERB_SET_STREAM_FORMAT, 0);

	dd = (struct hdac_ext_dma_params *)snd_soc_dai_get_dma_data(dai, substream);
	snd_soc_dai_set_dma_data(dai, substream, NULL);

	kfree(dd);

	return 0;
}

static int hdac_hdmi_pcm_open(struct snd_pcm_substream *substream,
			struct snd_soc_dai *dai)
{
	struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai);
	struct hdac_hdmi_priv *hdmi = hdac->private_data;
	struct hdac_hdmi_dai_pin_map *dai_map;
	int val;

	if (dai->id > 0) {
		dev_err(&hdac->hdac.dev, "Only one dai supported as of now\n");
		return -ENODEV;
	}

	dai_map = &hdmi->dai_map[dai->id];

	val = snd_hdac_codec_read(&hdac->hdac, dai_map->pin->nid, 0,
					AC_VERB_GET_PIN_SENSE, 0);
	dev_info(&hdac->hdac.dev, "Val for AC_VERB_GET_PIN_SENSE: %x\n", val);

	if ((!(val & AC_PINSENSE_PRESENCE)) || (!(val & AC_PINSENSE_ELDV))) {
		dev_err(&hdac->hdac.dev, "Monitor presence invalid with val: %x\n", val);
		return -ENODEV;
	}

	hdac_hdmi_set_power_state(hdac, dai_map, AC_PWRST_D0);

	snd_hdac_codec_write(&hdac->hdac, dai_map->pin->nid, 0,
			AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);

	snd_pcm_hw_constraint_step(substream->runtime, 0,
				   SNDRV_PCM_HW_PARAM_CHANNELS, 2);

	return 0;
}

static void hdac_hdmi_pcm_close(struct snd_pcm_substream *substream,
		struct snd_soc_dai *dai)
{
	struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai);
	struct hdac_hdmi_priv *hdmi = hdac->private_data;
	struct hdac_hdmi_dai_pin_map *dai_map;

	dai_map = &hdmi->dai_map[dai->id];

	hdac_hdmi_set_power_state(hdac, dai_map, AC_PWRST_D3);

	snd_hdac_codec_write(&hdac->hdac, dai_map->pin->nid, 0,
			AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
}

static int
hdac_hdmi_query_cvt_params(struct hdac_device *hdac, struct hdac_hdmi_cvt *cvt)
{
	int err;

	/* Only stereo supported as of now */
	cvt->params.channels_min = cvt->params.channels_max = 2;

	err = snd_hdac_query_supported_pcm(hdac, cvt->nid,
			&cvt->params.rates,
			&cvt->params.formats,
			&cvt->params.maxbps);
	if (err < 0)
		dev_err(&hdac->dev,
			"Failed to query pcm params for nid %d: %d\n",
			cvt->nid, err);

	return err;
}

static void hdac_hdmi_fill_widget_info(struct snd_soc_dapm_widget *w,
				enum snd_soc_dapm_type id,
				const char *wname, const char *stream)
{
	w->id = id;
	w->name = wname;
	w->sname = stream;
	w->reg = SND_SOC_NOPM;
	w->shift = 0;
	w->kcontrol_news = NULL;
	w->num_kcontrols = 0;
	w->priv = NULL;
}

static void hdac_hdmi_fill_route(struct snd_soc_dapm_route *route,
		const char *sink, const char *control, const char *src)
{
	route->sink = sink;
	route->source = src;
	route->control = control;
	route->connected = NULL;
}

static void create_fill_widget_route_map(struct snd_soc_dapm_context *dapm,
					struct hdac_hdmi_dai_pin_map *dai_map)
{
	struct snd_soc_dapm_route route[1];
	struct snd_soc_dapm_widget widgets[2] = { {0} };

	memset(&route, 0, sizeof(route));

	hdac_hdmi_fill_widget_info(&widgets[0], snd_soc_dapm_output,
			"hif1 Output", NULL);
	hdac_hdmi_fill_widget_info(&widgets[1], snd_soc_dapm_aif_in,
			"Coverter 1", "hif1");

	hdac_hdmi_fill_route(&route[0], "hif1 Output", NULL, "Coverter 1");

	snd_soc_dapm_new_controls(dapm, widgets, ARRAY_SIZE(widgets));
	snd_soc_dapm_add_routes(dapm, route, ARRAY_SIZE(route));
}

static int hdac_hdmi_init_dai_map(struct hdac_ext_device *edev)
{
	struct hdac_hdmi_priv *hdmi = edev->private_data;
	struct hdac_hdmi_dai_pin_map *dai_map = &hdmi->dai_map[0];
	struct hdac_hdmi_cvt *cvt;
	struct hdac_hdmi_pin *pin;

	if (list_empty(&hdmi->cvt_list) || list_empty(&hdmi->pin_list))
		return -EINVAL;

	/*
	 * Currently on board only 1 pin and 1 converter is enabled for
	 * simplification, more will be added eventually
	 * So using fixed map for dai_id:pin:cvt
	 */
	cvt = list_first_entry(&hdmi->cvt_list, struct hdac_hdmi_cvt, head);
	pin = list_first_entry(&hdmi->pin_list, struct hdac_hdmi_pin, head);

	dai_map->dai_id = 0;
	dai_map->pin = pin;

	dai_map->cvt = cvt;

	/* Enable out path for this pin widget */
	snd_hdac_codec_write(&edev->hdac, pin->nid, 0,
			AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);

	/* Enable transmission */
	snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,
			AC_VERB_SET_DIGI_CONVERT_1, 1);

	/* Category Code (CC) to zero */
	snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,
			AC_VERB_SET_DIGI_CONVERT_2, 0);

	snd_hdac_codec_write(&edev->hdac, pin->nid, 0,
			AC_VERB_SET_CONNECT_SEL, 0);

	return 0;
}

static int hdac_hdmi_add_cvt(struct hdac_ext_device *edev, hda_nid_t nid)
{
	struct hdac_hdmi_priv *hdmi = edev->private_data;
	struct hdac_hdmi_cvt *cvt;

	cvt = kzalloc(sizeof(*cvt), GFP_KERNEL);
	if (!cvt)
		return -ENOMEM;

	cvt->nid = nid;

	list_add_tail(&cvt->head, &hdmi->cvt_list);
	hdmi->num_cvt++;

	return hdac_hdmi_query_cvt_params(&edev->hdac, cvt);
}

static int hdac_hdmi_add_pin(struct hdac_ext_device *edev, hda_nid_t nid)
{
	struct hdac_hdmi_priv *hdmi = edev->private_data;
	struct hdac_hdmi_pin *pin;

	pin = kzalloc(sizeof(*pin), GFP_KERNEL);
	if (!pin)
		return -ENOMEM;

	pin->nid = nid;

	list_add_tail(&pin->head, &hdmi->pin_list);
	hdmi->num_pin++;

	return 0;
}

/*
 * Parse all nodes and store the cvt/pin nids in array
 * Add one time initialization for pin and cvt widgets
 */
static int hdac_hdmi_parse_and_map_nid(struct hdac_ext_device *edev)
{
	hda_nid_t nid;
	int i, num_nodes;
	struct hdac_device *hdac = &edev->hdac;
	struct hdac_hdmi_priv *hdmi = edev->private_data;
	int ret;

	num_nodes = snd_hdac_get_sub_nodes(hdac, hdac->afg, &nid);
	if (!nid || num_nodes <= 0) {
		dev_warn(&hdac->dev, "HDMI: failed to get afg sub nodes\n");
		return -EINVAL;
	}

	hdac->num_nodes = num_nodes;
	hdac->start_nid = nid;

	for (i = 0; i < hdac->num_nodes; i++, nid++) {
		unsigned int caps;
		unsigned int type;

		caps = get_wcaps(hdac, nid);
		type = get_wcaps_type(caps);

		if (!(caps & AC_WCAP_DIGITAL))
			continue;

		switch (type) {

		case AC_WID_AUD_OUT:
			ret = hdac_hdmi_add_cvt(edev, nid);
			if (ret < 0)
				return ret;
			break;

		case AC_WID_PIN:
			ret = hdac_hdmi_add_pin(edev, nid);
			if (ret < 0)
				return ret;
			break;
		}
	}

	hdac->end_nid = nid;

	if (!hdmi->num_pin || !hdmi->num_cvt)
		return -EIO;

	return hdac_hdmi_init_dai_map(edev);
}

static int hdmi_codec_probe(struct snd_soc_codec *codec)
{
	struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec);
	struct hdac_hdmi_priv *hdmi = edev->private_data;
	struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(&codec->component);

	edev->scodec = codec;

	create_fill_widget_route_map(dapm, &hdmi->dai_map[0]);

	/* Imp: Store the card pointer in hda_codec */
	edev->card = dapm->card->snd_card;

	/*
	 * hdac_device core already sets the state to active and calls
	 * get_noresume. So enable runtime and set the device to suspend.
	 */
	pm_runtime_enable(&edev->hdac.dev);
	pm_runtime_put(&edev->hdac.dev);
	pm_runtime_suspend(&edev->hdac.dev);

	return 0;
}

static int hdmi_codec_remove(struct snd_soc_codec *codec)
{
	struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec);

	pm_runtime_disable(&edev->hdac.dev);
	return 0;
}

static struct snd_soc_codec_driver hdmi_hda_codec = {
	.probe		= hdmi_codec_probe,
	.remove		= hdmi_codec_remove,
	.idle_bias_off	= true,
};

static struct snd_soc_dai_ops hdmi_dai_ops = {
	.startup = hdac_hdmi_pcm_open,
	.shutdown = hdac_hdmi_pcm_close,
	.hw_params = hdac_hdmi_set_hw_params,
	.prepare = hdac_hdmi_playback_prepare,
	.hw_free = hdac_hdmi_playback_cleanup,
};

static struct snd_soc_dai_driver hdmi_dais[] = {
	{	.name = "intel-hdmi-hif1",
		.playback = {
			.stream_name = "hif1",
			.channels_min = 2,
			.channels_max = 2,
			.rates = SNDRV_PCM_RATE_32000 |
				SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
				SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 |
				SNDRV_PCM_RATE_176400 | SNDRV_PCM_RATE_192000,
			.formats = SNDRV_PCM_FMTBIT_S16_LE |
				SNDRV_PCM_FMTBIT_S20_3LE |
				SNDRV_PCM_FMTBIT_S24_LE |
				SNDRV_PCM_FMTBIT_S32_LE,

		},
		.ops = &hdmi_dai_ops,
	},
};

static int hdac_hdmi_dev_probe(struct hdac_ext_device *edev)
{
	struct hdac_device *codec = &edev->hdac;
	struct hdac_hdmi_priv *hdmi_priv;
	int ret = 0;

	hdmi_priv = devm_kzalloc(&codec->dev, sizeof(*hdmi_priv), GFP_KERNEL);
	if (hdmi_priv == NULL)
		return -ENOMEM;

	edev->private_data = hdmi_priv;

	dev_set_drvdata(&codec->dev, edev);

	INIT_LIST_HEAD(&hdmi_priv->pin_list);
	INIT_LIST_HEAD(&hdmi_priv->cvt_list);

	ret = hdac_hdmi_parse_and_map_nid(edev);
	if (ret < 0)
		return ret;

	/* ASoC specific initialization */
	return snd_soc_register_codec(&codec->dev, &hdmi_hda_codec,
			hdmi_dais, ARRAY_SIZE(hdmi_dais));
}

static int hdac_hdmi_dev_remove(struct hdac_ext_device *edev)
{
	struct hdac_hdmi_priv *hdmi = edev->private_data;
	struct hdac_hdmi_pin *pin, *pin_next;
	struct hdac_hdmi_cvt *cvt, *cvt_next;

	snd_soc_unregister_codec(&edev->hdac.dev);

	list_for_each_entry_safe(cvt, cvt_next, &hdmi->cvt_list, head) {
		list_del(&cvt->head);
		kfree(cvt);
	}

	list_for_each_entry_safe(pin, pin_next, &hdmi->pin_list, head) {
		list_del(&pin->head);
		kfree(pin);
	}

	return 0;
}

#ifdef CONFIG_PM
static int hdac_hdmi_runtime_suspend(struct device *dev)
{
	struct hdac_ext_device *edev = to_hda_ext_device(dev);
	struct hdac_device *hdac = &edev->hdac;
	struct hdac_bus *bus = hdac->bus;
	int err;

	dev_dbg(dev, "Enter: %s\n", __func__);

	/* controller may not have been initialized for the first time */
	if (!bus)
		return 0;

	/* Power down afg */
	if (!snd_hdac_check_power_state(hdac, hdac->afg, AC_PWRST_D3))
		snd_hdac_codec_write(hdac, hdac->afg, 0,
			AC_VERB_SET_POWER_STATE, AC_PWRST_D3);

	err = snd_hdac_display_power(bus, false);
	if (err < 0) {
		dev_err(bus->dev, "Cannot turn on display power on i915\n");
		return err;
	}

	return 0;
}

static int hdac_hdmi_runtime_resume(struct device *dev)
{
	struct hdac_ext_device *edev = to_hda_ext_device(dev);
	struct hdac_device *hdac = &edev->hdac;
	struct hdac_bus *bus = hdac->bus;
	int err;

	dev_dbg(dev, "Enter: %s\n", __func__);

	/* controller may not have been initialized for the first time */
	if (!bus)
		return 0;

	err = snd_hdac_display_power(bus, true);
	if (err < 0) {
		dev_err(bus->dev, "Cannot turn on display power on i915\n");
		return err;
	}

	/* Power up afg */
	if (!snd_hdac_check_power_state(hdac, hdac->afg, AC_PWRST_D0))
		snd_hdac_codec_write(hdac, hdac->afg, 0,
			AC_VERB_SET_POWER_STATE, AC_PWRST_D0);

	return 0;
}
#else
#define hdac_hdmi_runtime_suspend NULL
#define hdac_hdmi_runtime_resume NULL
#endif

static const struct dev_pm_ops hdac_hdmi_pm = {
	SET_RUNTIME_PM_OPS(hdac_hdmi_runtime_suspend, hdac_hdmi_runtime_resume, NULL)
};

static const struct hda_device_id hdmi_list[] = {
	HDA_CODEC_EXT_ENTRY(0x80862809, 0x100000, "Skylake HDMI", 0),
	{}
};

MODULE_DEVICE_TABLE(hdaudio, hdmi_list);

static struct hdac_ext_driver hdmi_driver = {
	. hdac = {
		.driver = {
			.name   = "HDMI HDA Codec",
			.pm = &hdac_hdmi_pm,
		},
		.id_table       = hdmi_list,
	},
	.probe          = hdac_hdmi_dev_probe,
	.remove         = hdac_hdmi_dev_remove,
};

static int __init hdmi_init(void)
{
	return snd_hda_ext_driver_register(&hdmi_driver);
}

static void __exit hdmi_exit(void)
{
	snd_hda_ext_driver_unregister(&hdmi_driver);
}

module_init(hdmi_init);
module_exit(hdmi_exit);

MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("HDMI HD codec");
MODULE_AUTHOR("Samreen Nilofer<samreen.nilofer@intel.com>");
MODULE_AUTHOR("Subhransu S. Prusty<subhransu.s.prusty@intel.com>");
Commit	Line	Data
18382ead SP	1	/*
	2	* hdac_hdmi.c - ASoc HDA-HDMI codec driver for Intel platforms
	3	*
	4	* Copyright (C) 2014-2015 Intel Corp
	5	* Author: Samreen Nilofer <samreen.nilofer@intel.com>
	6	* Subhransu S. Prusty <subhransu.s.prusty@intel.com>
	7	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; version 2 of the License.
	12	*
	13	* This program is distributed in the hope that it will be useful, but
	14	* WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* General Public License for more details.
	17	*
	18	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	19	*/
	20	#include <linux/init.h>
	21	#include <linux/delay.h>
	22	#include <linux/module.h>
	23	#include <linux/pm_runtime.h>
a657f1d0	24	#include <linux/hdmi.h>
18382ead SP	25	#include <sound/pcm_params.h>
	26	#include <sound/soc.h>
	27	#include <sound/hdaudio_ext.h>
07f083ab	28	#include <sound/hda_i915.h>
18382ead SP	29	#include "../../hda/local.h"
18382ead SP	30
b0362adb SP	31	#define AMP_OUT_MUTE 0xb080
b0362adb SP	32	#define AMP_OUT_UNMUTE 0xb000
18382ead	33	#define PIN_OUT (AC_PINCTL_OUT_EN)
b0362adb	34
18382ead SP	35	#define HDA_MAX_CONNECTIONS 32
	36
	37	struct hdac_hdmi_cvt_params {
	38	unsigned int channels_min;
	39	unsigned int channels_max;
	40	u32 rates;
	41	u64 formats;
	42	unsigned int maxbps;
	43	};
	44
	45	struct hdac_hdmi_cvt {
15b91447	46	struct list_head head;
18382ead SP	47	hda_nid_t nid;
	48	struct hdac_hdmi_cvt_params params;
	49	};
	50
	51	struct hdac_hdmi_pin {
15b91447	52	struct list_head head;
18382ead SP	53	hda_nid_t nid;
	54	int num_mux_nids;
	55	hda_nid_t mux_nids[HDA_MAX_CONNECTIONS];
	56	};
	57
	58	struct hdac_hdmi_dai_pin_map {
	59	int dai_id;
15b91447 SP	60	struct hdac_hdmi_pin *pin;
15b91447 SP	61	struct hdac_hdmi_cvt *cvt;
18382ead SP	62	};
	63
	64	struct hdac_hdmi_priv {
18382ead	65	struct hdac_hdmi_dai_pin_map dai_map[3];
15b91447 SP	66	struct list_head pin_list;
	67	struct list_head cvt_list;
	68	int num_pin;
	69	int num_cvt;
18382ead SP	70	};
18382ead SP	71
e342ac08 SP	72	static inline struct hdac_ext_device to_hda_ext_device(struct device dev)
e342ac08 SP	73	{
51b2c425	74	struct hdac_device *hdac = dev_to_hdac_dev(dev);
e342ac08	75
51b2c425	76	return to_ehdac_device(hdac);
e342ac08 SP	77	}
e342ac08 SP	78
b0362adb SP	79	static int hdac_hdmi_setup_stream(struct hdac_ext_device *hdac,
	80	hda_nid_t cvt_nid, hda_nid_t pin_nid,
	81	u32 stream_tag, int format)
	82	{
	83	unsigned int val;
	84
	85	dev_dbg(&hdac->hdac.dev, "cvt nid %d pnid %d stream %d format 0x%x\n",
	86	cvt_nid, pin_nid, stream_tag, format);
	87
	88	val = (stream_tag << 4);
	89
	90	snd_hdac_codec_write(&hdac->hdac, cvt_nid, 0,
	91	AC_VERB_SET_CHANNEL_STREAMID, val);
	92	snd_hdac_codec_write(&hdac->hdac, cvt_nid, 0,
	93	AC_VERB_SET_STREAM_FORMAT, format);
	94
	95	return 0;
	96	}
	97
a657f1d0 SP	98	static void
	99	hdac_hdmi_set_dip_index(struct hdac_ext_device *hdac, hda_nid_t pin_nid,
	100	int packet_index, int byte_index)
	101	{
	102	int val;
	103
	104	val = (packet_index << 5) \| (byte_index & 0x1f);
	105
	106	snd_hdac_codec_write(&hdac->hdac, pin_nid, 0,
	107	AC_VERB_SET_HDMI_DIP_INDEX, val);
	108	}
	109
	110	static int hdac_hdmi_setup_audio_infoframe(struct hdac_ext_device *hdac,
	111	hda_nid_t cvt_nid, hda_nid_t pin_nid)
	112	{
	113	uint8_t buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AUDIO_INFOFRAME_SIZE];
	114	struct hdmi_audio_infoframe frame;
	115	u8 dip = (u8 )&frame;
	116	int ret;
	117	int i;
	118
	119	hdmi_audio_infoframe_init(&frame);
	120
	121	/* Default stereo for now */
	122	frame.channels = 2;
	123
	124	/* setup channel count */
	125	snd_hdac_codec_write(&hdac->hdac, cvt_nid, 0,
	126	AC_VERB_SET_CVT_CHAN_COUNT, frame.channels - 1);
	127
	128	ret = hdmi_audio_infoframe_pack(&frame, buffer, sizeof(buffer));
	129	if (ret < 0)
	130	return ret;
	131
	132	/* stop infoframe transmission */
	133	hdac_hdmi_set_dip_index(hdac, pin_nid, 0x0, 0x0);
	134	snd_hdac_codec_write(&hdac->hdac, pin_nid, 0,
	135	AC_VERB_SET_HDMI_DIP_XMIT, AC_DIPXMIT_DISABLE);
	136
	137
	138	/* Fill infoframe. Index auto-incremented */
	139	hdac_hdmi_set_dip_index(hdac, pin_nid, 0x0, 0x0);
	140	for (i = 0; i < sizeof(frame); i++)
	141	snd_hdac_codec_write(&hdac->hdac, pin_nid, 0,
	142	AC_VERB_SET_HDMI_DIP_DATA, dip[i]);
	143
	144	/* Start infoframe */
	145	hdac_hdmi_set_dip_index(hdac, pin_nid, 0x0, 0x0);
	146	snd_hdac_codec_write(&hdac->hdac, pin_nid, 0,
	147	AC_VERB_SET_HDMI_DIP_XMIT, AC_DIPXMIT_BEST);
	148
	149	return 0;
	150	}
	151
b0362adb SP	152	static void hdac_hdmi_set_power_state(struct hdac_ext_device *edev,
	153	struct hdac_hdmi_dai_pin_map *dai_map, unsigned int pwr_state)
	154	{
	155	/* Power up pin widget */
15b91447 SP	156	if (!snd_hdac_check_power_state(&edev->hdac, dai_map->pin->nid,
	157	pwr_state))
	158	snd_hdac_codec_write(&edev->hdac, dai_map->pin->nid, 0,
b0362adb SP	159	AC_VERB_SET_POWER_STATE, pwr_state);
	160
	161	/* Power up converter */
15b91447 SP	162	if (!snd_hdac_check_power_state(&edev->hdac, dai_map->cvt->nid,
	163	pwr_state))
	164	snd_hdac_codec_write(&edev->hdac, dai_map->cvt->nid, 0,
b0362adb SP	165	AC_VERB_SET_POWER_STATE, pwr_state);
	166	}
	167
	168	static int hdac_hdmi_playback_prepare(struct snd_pcm_substream *substream,
	169	struct snd_soc_dai *dai)
	170	{
	171	struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai);
	172	struct hdac_hdmi_priv *hdmi = hdac->private_data;
	173	struct hdac_hdmi_dai_pin_map *dai_map;
	174	struct hdac_ext_dma_params *dd;
a657f1d0	175	int ret;
b0362adb SP	176
	177	if (dai->id > 0) {
	178	dev_err(&hdac->hdac.dev, "Only one dai supported as of now\n");
	179	return -ENODEV;
	180	}
	181
	182	dai_map = &hdmi->dai_map[dai->id];
	183
	184	dd = (struct hdac_ext_dma_params *)snd_soc_dai_get_dma_data(dai, substream);
	185	dev_dbg(&hdac->hdac.dev, "stream tag from cpu dai %d format in cvt 0x%x\n",
	186	dd->stream_tag, dd->format);
	187
15b91447 SP	188	ret = hdac_hdmi_setup_audio_infoframe(hdac, dai_map->cvt->nid,
15b91447 SP	189	dai_map->pin->nid);
a657f1d0 SP	190	if (ret < 0)
	191	return ret;
	192
15b91447 SP	193	return hdac_hdmi_setup_stream(hdac, dai_map->cvt->nid,
15b91447 SP	194	dai_map->pin->nid, dd->stream_tag, dd->format);
b0362adb SP	195	}
	196
	197	static int hdac_hdmi_set_hw_params(struct snd_pcm_substream *substream,
	198	struct snd_pcm_hw_params hparams, struct snd_soc_dai dai)
	199	{
	200	struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai);
	201	struct hdac_ext_dma_params *dd;
	202
	203	if (dai->id > 0) {
	204	dev_err(&hdac->hdac.dev, "Only one dai supported as of now\n");
	205	return -ENODEV;
	206	}
	207
	208	dd = kzalloc(sizeof(*dd), GFP_KERNEL);
8d33ab24 SM	209	if (!dd)
8d33ab24 SM	210	return -ENOMEM;
b0362adb SP	211	dd->format = snd_hdac_calc_stream_format(params_rate(hparams),
	212	params_channels(hparams), params_format(hparams),
	213	24, 0);
	214
	215	snd_soc_dai_set_dma_data(dai, substream, (void *)dd);
	216
	217	return 0;
	218	}
	219
	220	static int hdac_hdmi_playback_cleanup(struct snd_pcm_substream *substream,
	221	struct snd_soc_dai *dai)
	222	{
	223	struct hdac_ext_device *edev = snd_soc_dai_get_drvdata(dai);
	224	struct hdac_ext_dma_params *dd;
	225	struct hdac_hdmi_priv *hdmi = edev->private_data;
	226	struct hdac_hdmi_dai_pin_map *dai_map;
	227
	228	dai_map = &hdmi->dai_map[dai->id];
	229
15b91447	230	snd_hdac_codec_write(&edev->hdac, dai_map->cvt->nid, 0,
b0362adb	231	AC_VERB_SET_CHANNEL_STREAMID, 0);
15b91447	232	snd_hdac_codec_write(&edev->hdac, dai_map->cvt->nid, 0,
b0362adb SP	233	AC_VERB_SET_STREAM_FORMAT, 0);
	234
	235	dd = (struct hdac_ext_dma_params *)snd_soc_dai_get_dma_data(dai, substream);
	236	snd_soc_dai_set_dma_data(dai, substream, NULL);
	237
	238	kfree(dd);
	239
	240	return 0;
	241	}
	242
	243	static int hdac_hdmi_pcm_open(struct snd_pcm_substream *substream,
	244	struct snd_soc_dai *dai)
	245	{
	246	struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai);
	247	struct hdac_hdmi_priv *hdmi = hdac->private_data;
	248	struct hdac_hdmi_dai_pin_map *dai_map;
	249	int val;
	250
	251	if (dai->id > 0) {
	252	dev_err(&hdac->hdac.dev, "Only one dai supported as of now\n");
	253	return -ENODEV;
	254	}
	255
	256	dai_map = &hdmi->dai_map[dai->id];
	257
15b91447	258	val = snd_hdac_codec_read(&hdac->hdac, dai_map->pin->nid, 0,
b0362adb SP	259	AC_VERB_GET_PIN_SENSE, 0);
	260	dev_info(&hdac->hdac.dev, "Val for AC_VERB_GET_PIN_SENSE: %x\n", val);
	261
	262	if ((!(val & AC_PINSENSE_PRESENCE)) \|\| (!(val & AC_PINSENSE_ELDV))) {
	263	dev_err(&hdac->hdac.dev, "Monitor presence invalid with val: %x\n", val);
	264	return -ENODEV;
	265	}
	266
	267	hdac_hdmi_set_power_state(hdac, dai_map, AC_PWRST_D0);
	268
15b91447	269	snd_hdac_codec_write(&hdac->hdac, dai_map->pin->nid, 0,
b0362adb SP	270	AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
	271
	272	snd_pcm_hw_constraint_step(substream->runtime, 0,
	273	SNDRV_PCM_HW_PARAM_CHANNELS, 2);
	274
	275	return 0;
	276	}
	277
	278	static void hdac_hdmi_pcm_close(struct snd_pcm_substream *substream,
	279	struct snd_soc_dai *dai)
	280	{
	281	struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai);
	282	struct hdac_hdmi_priv *hdmi = hdac->private_data;
	283	struct hdac_hdmi_dai_pin_map *dai_map;
	284
	285	dai_map = &hdmi->dai_map[dai->id];
	286
	287	hdac_hdmi_set_power_state(hdac, dai_map, AC_PWRST_D3);
	288
15b91447	289	snd_hdac_codec_write(&hdac->hdac, dai_map->pin->nid, 0,
b0362adb SP	290	AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
	291	}
	292
18382ead SP	293	static int
	294	hdac_hdmi_query_cvt_params(struct hdac_device hdac, struct hdac_hdmi_cvt cvt)
	295	{
	296	int err;
	297
	298	/* Only stereo supported as of now */
	299	cvt->params.channels_min = cvt->params.channels_max = 2;
	300
	301	err = snd_hdac_query_supported_pcm(hdac, cvt->nid,
	302	&cvt->params.rates,
	303	&cvt->params.formats,
	304	&cvt->params.maxbps);
	305	if (err < 0)
	306	dev_err(&hdac->dev,
	307	"Failed to query pcm params for nid %d: %d\n",
	308	cvt->nid, err);
	309
	310	return err;
	311	}
	312
18382ead SP	313	static void hdac_hdmi_fill_widget_info(struct snd_soc_dapm_widget *w,
	314	enum snd_soc_dapm_type id,
	315	const char wname, const char stream)
	316	{
	317	w->id = id;
	318	w->name = wname;
	319	w->sname = stream;
	320	w->reg = SND_SOC_NOPM;
	321	w->shift = 0;
	322	w->kcontrol_news = NULL;
	323	w->num_kcontrols = 0;
	324	w->priv = NULL;
	325	}
	326
	327	static void hdac_hdmi_fill_route(struct snd_soc_dapm_route *route,
	328	const char sink, const char control, const char *src)
	329	{
	330	route->sink = sink;
	331	route->source = src;
	332	route->control = control;
	333	route->connected = NULL;
	334	}
	335
	336	static void create_fill_widget_route_map(struct snd_soc_dapm_context *dapm,
	337	struct hdac_hdmi_dai_pin_map *dai_map)
	338	{
	339	struct snd_soc_dapm_route route[1];
	340	struct snd_soc_dapm_widget widgets[2] = { {0} };
	341
	342	memset(&route, 0, sizeof(route));
	343
	344	hdac_hdmi_fill_widget_info(&widgets[0], snd_soc_dapm_output,
	345	"hif1 Output", NULL);
	346	hdac_hdmi_fill_widget_info(&widgets[1], snd_soc_dapm_aif_in,
	347	"Coverter 1", "hif1");
	348
	349	hdac_hdmi_fill_route(&route[0], "hif1 Output", NULL, "Coverter 1");
	350
	351	snd_soc_dapm_new_controls(dapm, widgets, ARRAY_SIZE(widgets));
	352	snd_soc_dapm_add_routes(dapm, route, ARRAY_SIZE(route));
	353	}
	354
15b91447	355	static int hdac_hdmi_init_dai_map(struct hdac_ext_device *edev)
18382ead	356	{
15b91447 SP	357	struct hdac_hdmi_priv *hdmi = edev->private_data;
	358	struct hdac_hdmi_dai_pin_map *dai_map = &hdmi->dai_map[0];
	359	struct hdac_hdmi_cvt *cvt;
	360	struct hdac_hdmi_pin *pin;
18382ead	361
15b91447 SP	362	if (list_empty(&hdmi->cvt_list) \|\| list_empty(&hdmi->pin_list))
15b91447 SP	363	return -EINVAL;
18382ead	364
15b91447 SP	365	/*
	366	* Currently on board only 1 pin and 1 converter is enabled for
	367	* simplification, more will be added eventually
	368	* So using fixed map for dai_id:pin:cvt
	369	*/
	370	cvt = list_first_entry(&hdmi->cvt_list, struct hdac_hdmi_cvt, head);
	371	pin = list_first_entry(&hdmi->pin_list, struct hdac_hdmi_pin, head);
	372
	373	dai_map->dai_id = 0;
	374	dai_map->pin = pin;
18382ead	375
15b91447	376	dai_map->cvt = cvt;
18382ead SP	377
18382ead SP	378	/* Enable out path for this pin widget */
15b91447	379	snd_hdac_codec_write(&edev->hdac, pin->nid, 0,
18382ead SP	380	AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
	381
	382	/* Enable transmission */
15b91447	383	snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,
18382ead SP	384	AC_VERB_SET_DIGI_CONVERT_1, 1);
	385
	386	/* Category Code (CC) to zero */
15b91447	387	snd_hdac_codec_write(&edev->hdac, cvt->nid, 0,
18382ead SP	388	AC_VERB_SET_DIGI_CONVERT_2, 0);
18382ead SP	389
15b91447	390	snd_hdac_codec_write(&edev->hdac, pin->nid, 0,
18382ead SP	391	AC_VERB_SET_CONNECT_SEL, 0);
18382ead SP	392
15b91447 SP	393	return 0;
	394	}
	395
	396	static int hdac_hdmi_add_cvt(struct hdac_ext_device *edev, hda_nid_t nid)
	397	{
	398	struct hdac_hdmi_priv *hdmi = edev->private_data;
	399	struct hdac_hdmi_cvt *cvt;
	400
	401	cvt = kzalloc(sizeof(*cvt), GFP_KERNEL);
	402	if (!cvt)
	403	return -ENOMEM;
	404
	405	cvt->nid = nid;
	406
	407	list_add_tail(&cvt->head, &hdmi->cvt_list);
	408	hdmi->num_cvt++;
	409
	410	return hdac_hdmi_query_cvt_params(&edev->hdac, cvt);
	411	}
	412
	413	static int hdac_hdmi_add_pin(struct hdac_ext_device *edev, hda_nid_t nid)
	414	{
	415	struct hdac_hdmi_priv *hdmi = edev->private_data;
	416	struct hdac_hdmi_pin *pin;
	417
	418	pin = kzalloc(sizeof(*pin), GFP_KERNEL);
	419	if (!pin)
	420	return -ENOMEM;
	421
	422	pin->nid = nid;
	423
	424	list_add_tail(&pin->head, &hdmi->pin_list);
	425	hdmi->num_pin++;
	426
	427	return 0;
18382ead SP	428	}
	429
	430	/*
	431	* Parse all nodes and store the cvt/pin nids in array
	432	* Add one time initialization for pin and cvt widgets
	433	*/
	434	static int hdac_hdmi_parse_and_map_nid(struct hdac_ext_device *edev)
	435	{
	436	hda_nid_t nid;
3c83ac23	437	int i, num_nodes;
18382ead SP	438	struct hdac_device *hdac = &edev->hdac;
18382ead SP	439	struct hdac_hdmi_priv *hdmi = edev->private_data;
15b91447	440	int ret;
18382ead	441
3c83ac23	442	num_nodes = snd_hdac_get_sub_nodes(hdac, hdac->afg, &nid);
541140d4	443	if (!nid \|\| num_nodes <= 0) {
18382ead SP	444	dev_warn(&hdac->dev, "HDMI: failed to get afg sub nodes\n");
	445	return -EINVAL;
	446	}
	447
3c83ac23	448	hdac->num_nodes = num_nodes;
18382ead SP	449	hdac->start_nid = nid;
	450
	451	for (i = 0; i < hdac->num_nodes; i++, nid++) {
	452	unsigned int caps;
	453	unsigned int type;
	454
	455	caps = get_wcaps(hdac, nid);
	456	type = get_wcaps_type(caps);
	457
	458	if (!(caps & AC_WCAP_DIGITAL))
	459	continue;
	460
	461	switch (type) {
	462
	463	case AC_WID_AUD_OUT:
15b91447 SP	464	ret = hdac_hdmi_add_cvt(edev, nid);
	465	if (ret < 0)
	466	return ret;
18382ead SP	467	break;
	468
	469	case AC_WID_PIN:
15b91447 SP	470	ret = hdac_hdmi_add_pin(edev, nid);
	471	if (ret < 0)
	472	return ret;
18382ead SP	473	break;
	474	}
	475	}
	476
	477	hdac->end_nid = nid;
	478
15b91447	479	if (!hdmi->num_pin \|\| !hdmi->num_cvt)
18382ead SP	480	return -EIO;
18382ead SP	481
15b91447	482	return hdac_hdmi_init_dai_map(edev);
18382ead SP	483	}
	484
	485	static int hdmi_codec_probe(struct snd_soc_codec *codec)
	486	{
	487	struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec);
	488	struct hdac_hdmi_priv *hdmi = edev->private_data;
	489	struct snd_soc_dapm_context *dapm =
	490	snd_soc_component_get_dapm(&codec->component);
	491
	492	edev->scodec = codec;
	493
	494	create_fill_widget_route_map(dapm, &hdmi->dai_map[0]);
	495
	496	/* Imp: Store the card pointer in hda_codec */
	497	edev->card = dapm->card->snd_card;
	498
e342ac08 SP	499	/*
	500	* hdac_device core already sets the state to active and calls
	501	* get_noresume. So enable runtime and set the device to suspend.
	502	*/
	503	pm_runtime_enable(&edev->hdac.dev);
	504	pm_runtime_put(&edev->hdac.dev);
	505	pm_runtime_suspend(&edev->hdac.dev);
	506
	507	return 0;
	508	}
	509
	510	static int hdmi_codec_remove(struct snd_soc_codec *codec)
	511	{
	512	struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec);
	513
	514	pm_runtime_disable(&edev->hdac.dev);
18382ead SP	515	return 0;
	516	}
	517
	518	static struct snd_soc_codec_driver hdmi_hda_codec = {
	519	.probe = hdmi_codec_probe,
e342ac08	520	.remove = hdmi_codec_remove,
18382ead SP	521	.idle_bias_off = true,
	522	};
	523
b0362adb SP	524	static struct snd_soc_dai_ops hdmi_dai_ops = {
	525	.startup = hdac_hdmi_pcm_open,
	526	.shutdown = hdac_hdmi_pcm_close,
	527	.hw_params = hdac_hdmi_set_hw_params,
	528	.prepare = hdac_hdmi_playback_prepare,
	529	.hw_free = hdac_hdmi_playback_cleanup,
	530	};
	531
18382ead SP	532	static struct snd_soc_dai_driver hdmi_dais[] = {
	533	{ .name = "intel-hdmi-hif1",
	534	.playback = {
	535	.stream_name = "hif1",
	536	.channels_min = 2,
	537	.channels_max = 2,
	538	.rates = SNDRV_PCM_RATE_32000 \|
	539	SNDRV_PCM_RATE_44100 \| SNDRV_PCM_RATE_48000 \|
	540	SNDRV_PCM_RATE_88200 \| SNDRV_PCM_RATE_96000 \|
	541	SNDRV_PCM_RATE_176400 \| SNDRV_PCM_RATE_192000,
	542	.formats = SNDRV_PCM_FMTBIT_S16_LE \|
	543	SNDRV_PCM_FMTBIT_S20_3LE \|
	544	SNDRV_PCM_FMTBIT_S24_LE \|
	545	SNDRV_PCM_FMTBIT_S32_LE,
	546
	547	},
b0362adb	548	.ops = &hdmi_dai_ops,
18382ead SP	549	},
	550	};
	551
	552	static int hdac_hdmi_dev_probe(struct hdac_ext_device *edev)
	553	{
	554	struct hdac_device *codec = &edev->hdac;
	555	struct hdac_hdmi_priv *hdmi_priv;
	556	int ret = 0;
	557
	558	hdmi_priv = devm_kzalloc(&codec->dev, sizeof(*hdmi_priv), GFP_KERNEL);
	559	if (hdmi_priv == NULL)
	560	return -ENOMEM;
	561
	562	edev->private_data = hdmi_priv;
	563
	564	dev_set_drvdata(&codec->dev, edev);
	565
15b91447 SP	566	INIT_LIST_HEAD(&hdmi_priv->pin_list);
	567	INIT_LIST_HEAD(&hdmi_priv->cvt_list);
	568
18382ead SP	569	ret = hdac_hdmi_parse_and_map_nid(edev);
	570	if (ret < 0)
	571	return ret;
	572
	573	/* ASoC specific initialization */
	574	return snd_soc_register_codec(&codec->dev, &hdmi_hda_codec,
	575	hdmi_dais, ARRAY_SIZE(hdmi_dais));
	576	}
	577
	578	static int hdac_hdmi_dev_remove(struct hdac_ext_device *edev)
	579	{
15b91447 SP	580	struct hdac_hdmi_priv *hdmi = edev->private_data;
	581	struct hdac_hdmi_pin pin, pin_next;
	582	struct hdac_hdmi_cvt cvt, cvt_next;
	583
18382ead SP	584	snd_soc_unregister_codec(&edev->hdac.dev);
18382ead SP	585
15b91447 SP	586	list_for_each_entry_safe(cvt, cvt_next, &hdmi->cvt_list, head) {
	587	list_del(&cvt->head);
	588	kfree(cvt);
	589	}
	590
	591	list_for_each_entry_safe(pin, pin_next, &hdmi->pin_list, head) {
	592	list_del(&pin->head);
	593	kfree(pin);
	594	}
	595
18382ead SP	596	return 0;
	597	}
	598
e342ac08 SP	599	#ifdef CONFIG_PM
	600	static int hdac_hdmi_runtime_suspend(struct device *dev)
	601	{
	602	struct hdac_ext_device *edev = to_hda_ext_device(dev);
	603	struct hdac_device *hdac = &edev->hdac;
07f083ab SP	604	struct hdac_bus *bus = hdac->bus;
07f083ab SP	605	int err;
e342ac08 SP	606
	607	dev_dbg(dev, "Enter: %s\n", __func__);
	608
07f083ab SP	609	/* controller may not have been initialized for the first time */
	610	if (!bus)
	611	return 0;
	612
e342ac08 SP	613	/* Power down afg */
	614	if (!snd_hdac_check_power_state(hdac, hdac->afg, AC_PWRST_D3))
	615	snd_hdac_codec_write(hdac, hdac->afg, 0,
	616	AC_VERB_SET_POWER_STATE, AC_PWRST_D3);
	617
07f083ab SP	618	err = snd_hdac_display_power(bus, false);
	619	if (err < 0) {
	620	dev_err(bus->dev, "Cannot turn on display power on i915\n");
	621	return err;
	622	}
	623
e342ac08 SP	624	return 0;
	625	}
	626
	627	static int hdac_hdmi_runtime_resume(struct device *dev)
	628	{
	629	struct hdac_ext_device *edev = to_hda_ext_device(dev);
	630	struct hdac_device *hdac = &edev->hdac;
07f083ab SP	631	struct hdac_bus *bus = hdac->bus;
07f083ab SP	632	int err;
e342ac08 SP	633
	634	dev_dbg(dev, "Enter: %s\n", __func__);
	635
07f083ab SP	636	/* controller may not have been initialized for the first time */
	637	if (!bus)
	638	return 0;
	639
	640	err = snd_hdac_display_power(bus, true);
	641	if (err < 0) {
	642	dev_err(bus->dev, "Cannot turn on display power on i915\n");
	643	return err;
	644	}
	645
e342ac08 SP	646	/* Power up afg */
	647	if (!snd_hdac_check_power_state(hdac, hdac->afg, AC_PWRST_D0))
	648	snd_hdac_codec_write(hdac, hdac->afg, 0,
	649	AC_VERB_SET_POWER_STATE, AC_PWRST_D0);
	650
	651	return 0;
	652	}
	653	#else
	654	#define hdac_hdmi_runtime_suspend NULL
	655	#define hdac_hdmi_runtime_resume NULL
	656	#endif
	657
	658	static const struct dev_pm_ops hdac_hdmi_pm = {
	659	SET_RUNTIME_PM_OPS(hdac_hdmi_runtime_suspend, hdac_hdmi_runtime_resume, NULL)
	660	};
	661
18382ead SP	662	static const struct hda_device_id hdmi_list[] = {
	663	HDA_CODEC_EXT_ENTRY(0x80862809, 0x100000, "Skylake HDMI", 0),
	664	{}
	665	};
	666
	667	MODULE_DEVICE_TABLE(hdaudio, hdmi_list);
	668
	669	static struct hdac_ext_driver hdmi_driver = {
	670	. hdac = {
	671	.driver = {
	672	.name = "HDMI HDA Codec",
e342ac08	673	.pm = &hdac_hdmi_pm,
18382ead SP	674	},
	675	.id_table = hdmi_list,
	676	},
	677	.probe = hdac_hdmi_dev_probe,
	678	.remove = hdac_hdmi_dev_remove,
	679	};
	680
	681	static int __init hdmi_init(void)
	682	{
	683	return snd_hda_ext_driver_register(&hdmi_driver);
	684	}
	685
	686	static void __exit hdmi_exit(void)
	687	{
	688	snd_hda_ext_driver_unregister(&hdmi_driver);
	689	}
	690
	691	module_init(hdmi_init);
	692	module_exit(hdmi_exit);
	693
	694	MODULE_LICENSE("GPL v2");
	695	MODULE_DESCRIPTION("HDMI HD codec");
	696	MODULE_AUTHOR("Samreen Nilofer<samreen.nilofer@intel.com>");
	697	MODULE_AUTHOR("Subhransu S. Prusty<subhransu.s.prusty@intel.com>");