xref: /linux/sound/soc/codecs/hdac_hdmi.c (revision 06d07429858317ded2db7986113a9e0129cd599b)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  hdac_hdmi.c - ASoc HDA-HDMI codec driver for Intel platforms
4  *
5  *  Copyright (C) 2014-2015 Intel Corp
6  *  Author: Samreen Nilofer <samreen.nilofer@intel.com>
7  *	    Subhransu S. Prusty <subhransu.s.prusty@intel.com>
8  *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
9  *
10  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11  */
12 
13 #include <linux/init.h>
14 #include <linux/delay.h>
15 #include <linux/module.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/hdmi.h>
18 #include <drm/drm_edid.h>
19 #include <drm/drm_eld.h>
20 #include <sound/pcm_params.h>
21 #include <sound/jack.h>
22 #include <sound/soc.h>
23 #include <sound/hdaudio_ext.h>
24 #include <sound/hda_i915.h>
25 #include <sound/pcm_drm_eld.h>
26 #include <sound/hda_chmap.h>
27 #include "../../hda/local.h"
28 #include "hdac_hdmi.h"
29 
30 #define NAME_SIZE	32
31 
32 #define AMP_OUT_MUTE		0xb080
33 #define AMP_OUT_UNMUTE		0xb000
34 #define PIN_OUT			(AC_PINCTL_OUT_EN)
35 
36 #define HDA_MAX_CONNECTIONS     32
37 
38 #define HDA_MAX_CVTS		3
39 #define HDA_MAX_PORTS		3
40 
41 #define ELD_MAX_SIZE    256
42 #define ELD_FIXED_BYTES	20
43 
44 #define ELD_VER_CEA_861D 2
45 #define ELD_VER_PARTIAL 31
46 #define ELD_MAX_MNL     16
47 
48 struct hdac_hdmi_cvt_params {
49 	unsigned int channels_min;
50 	unsigned int channels_max;
51 	u32 rates;
52 	u64 formats;
53 	unsigned int maxbps;
54 };
55 
56 struct hdac_hdmi_cvt {
57 	struct list_head head;
58 	hda_nid_t nid;
59 	const char *name;
60 	struct hdac_hdmi_cvt_params params;
61 };
62 
63 /* Currently only spk_alloc, more to be added */
64 struct hdac_hdmi_parsed_eld {
65 	u8 spk_alloc;
66 };
67 
68 struct hdac_hdmi_eld {
69 	bool	monitor_present;
70 	bool	eld_valid;
71 	int	eld_size;
72 	char    eld_buffer[ELD_MAX_SIZE];
73 	struct	hdac_hdmi_parsed_eld info;
74 };
75 
76 struct hdac_hdmi_pin {
77 	struct list_head head;
78 	hda_nid_t nid;
79 	bool mst_capable;
80 	struct hdac_hdmi_port *ports;
81 	int num_ports;
82 	struct hdac_device *hdev;
83 };
84 
85 struct hdac_hdmi_port {
86 	struct list_head head;
87 	int id;
88 	struct hdac_hdmi_pin *pin;
89 	int num_mux_nids;
90 	hda_nid_t mux_nids[HDA_MAX_CONNECTIONS];
91 	struct hdac_hdmi_eld eld;
92 	const char *jack_pin;
93 	bool is_connect;
94 	struct snd_soc_dapm_context *dapm;
95 	const char *output_pin;
96 	struct work_struct dapm_work;
97 };
98 
99 struct hdac_hdmi_pcm {
100 	struct list_head head;
101 	int pcm_id;
102 	struct list_head port_list;
103 	struct hdac_hdmi_cvt *cvt;
104 	struct snd_soc_jack *jack;
105 	int stream_tag;
106 	int channels;
107 	int format;
108 	bool chmap_set;
109 	unsigned char chmap[8]; /* ALSA API channel-map */
110 	struct mutex lock;
111 	int jack_event;
112 	struct snd_kcontrol *eld_ctl;
113 };
114 
115 struct hdac_hdmi_dai_port_map {
116 	int dai_id;
117 	struct hdac_hdmi_port *port;
118 	struct hdac_hdmi_cvt *cvt;
119 };
120 
121 struct hdac_hdmi_drv_data {
122 	unsigned int vendor_nid;
123 };
124 
125 struct hdac_hdmi_priv {
126 	struct hdac_device *hdev;
127 	struct snd_soc_component *component;
128 	struct snd_card *card;
129 	struct hdac_hdmi_dai_port_map dai_map[HDA_MAX_CVTS];
130 	struct list_head pin_list;
131 	struct list_head cvt_list;
132 	struct list_head pcm_list;
133 	int num_pin;
134 	int num_cvt;
135 	int num_ports;
136 	struct mutex pin_mutex;
137 	struct hdac_chmap chmap;
138 	struct hdac_hdmi_drv_data *drv_data;
139 	struct snd_soc_dai_driver *dai_drv;
140 };
141 
142 #define hdev_to_hdmi_priv(_hdev) dev_get_drvdata(&(_hdev)->dev)
143 
144 static struct hdac_hdmi_pcm *
hdac_hdmi_get_pcm_from_cvt(struct hdac_hdmi_priv * hdmi,struct hdac_hdmi_cvt * cvt)145 hdac_hdmi_get_pcm_from_cvt(struct hdac_hdmi_priv *hdmi,
146 			   struct hdac_hdmi_cvt *cvt)
147 {
148 	struct hdac_hdmi_pcm *pcm;
149 
150 	list_for_each_entry(pcm, &hdmi->pcm_list, head) {
151 		if (pcm->cvt == cvt)
152 			return pcm;
153 	}
154 
155 	return NULL;
156 }
157 
hdac_hdmi_jack_report(struct hdac_hdmi_pcm * pcm,struct hdac_hdmi_port * port,bool is_connect)158 static void hdac_hdmi_jack_report(struct hdac_hdmi_pcm *pcm,
159 		struct hdac_hdmi_port *port, bool is_connect)
160 {
161 	struct hdac_device *hdev = port->pin->hdev;
162 
163 	port->is_connect = is_connect;
164 	if (is_connect) {
165 		/*
166 		 * Report Jack connect event when a device is connected
167 		 * for the first time where same PCM is attached to multiple
168 		 * ports.
169 		 */
170 		if (pcm->jack_event == 0) {
171 			dev_dbg(&hdev->dev,
172 					"jack report for pcm=%d\n",
173 					pcm->pcm_id);
174 			snd_soc_jack_report(pcm->jack, SND_JACK_AVOUT,
175 						SND_JACK_AVOUT);
176 		}
177 		pcm->jack_event++;
178 	} else {
179 		/*
180 		 * Report Jack disconnect event when a device is disconnected
181 		 * is the only last connected device when same PCM is attached
182 		 * to multiple ports.
183 		 */
184 		if (pcm->jack_event == 1)
185 			snd_soc_jack_report(pcm->jack, 0, SND_JACK_AVOUT);
186 		if (pcm->jack_event > 0)
187 			pcm->jack_event--;
188 	}
189 }
190 
hdac_hdmi_port_dapm_update(struct hdac_hdmi_port * port)191 static void hdac_hdmi_port_dapm_update(struct hdac_hdmi_port *port)
192 {
193 	if (port->is_connect)
194 		snd_soc_dapm_enable_pin(port->dapm, port->jack_pin);
195 	else
196 		snd_soc_dapm_disable_pin(port->dapm, port->jack_pin);
197 	snd_soc_dapm_sync(port->dapm);
198 }
199 
hdac_hdmi_jack_dapm_work(struct work_struct * work)200 static void hdac_hdmi_jack_dapm_work(struct work_struct *work)
201 {
202 	struct hdac_hdmi_port *port;
203 
204 	port = container_of(work, struct hdac_hdmi_port, dapm_work);
205 	hdac_hdmi_port_dapm_update(port);
206 }
207 
hdac_hdmi_jack_report_sync(struct hdac_hdmi_pcm * pcm,struct hdac_hdmi_port * port,bool is_connect)208 static void hdac_hdmi_jack_report_sync(struct hdac_hdmi_pcm *pcm,
209 		struct hdac_hdmi_port *port, bool is_connect)
210 {
211 	hdac_hdmi_jack_report(pcm, port, is_connect);
212 	hdac_hdmi_port_dapm_update(port);
213 }
214 
215 /* MST supported verbs */
216 /*
217  * Get the no devices that can be connected to a port on the Pin widget.
218  */
hdac_hdmi_get_port_len(struct hdac_device * hdev,hda_nid_t nid)219 static int hdac_hdmi_get_port_len(struct hdac_device *hdev, hda_nid_t nid)
220 {
221 	unsigned int caps;
222 	unsigned int type, param;
223 
224 	caps = get_wcaps(hdev, nid);
225 	type = get_wcaps_type(caps);
226 
227 	if (!(caps & AC_WCAP_DIGITAL) || (type != AC_WID_PIN))
228 		return 0;
229 
230 	param = snd_hdac_read_parm_uncached(hdev, nid, AC_PAR_DEVLIST_LEN);
231 	if (param == -1)
232 		return param;
233 
234 	return param & AC_DEV_LIST_LEN_MASK;
235 }
236 
237 /*
238  * Get the port entry select on the pin. Return the port entry
239  * id selected on the pin. Return 0 means the first port entry
240  * is selected or MST is not supported.
241  */
hdac_hdmi_port_select_get(struct hdac_device * hdev,struct hdac_hdmi_port * port)242 static int hdac_hdmi_port_select_get(struct hdac_device *hdev,
243 					struct hdac_hdmi_port *port)
244 {
245 	return snd_hdac_codec_read(hdev, port->pin->nid,
246 				0, AC_VERB_GET_DEVICE_SEL, 0);
247 }
248 
249 /*
250  * Sets the selected port entry for the configuring Pin widget verb.
251  * returns error if port set is not equal to port get otherwise success
252  */
hdac_hdmi_port_select_set(struct hdac_device * hdev,struct hdac_hdmi_port * port)253 static int hdac_hdmi_port_select_set(struct hdac_device *hdev,
254 					struct hdac_hdmi_port *port)
255 {
256 	int num_ports;
257 
258 	if (!port->pin->mst_capable)
259 		return 0;
260 
261 	/* AC_PAR_DEVLIST_LEN is 0 based. */
262 	num_ports = hdac_hdmi_get_port_len(hdev, port->pin->nid);
263 	if (num_ports < 0)
264 		return -EIO;
265 	/*
266 	 * Device List Length is a 0 based integer value indicating the
267 	 * number of sink device that a MST Pin Widget can support.
268 	 */
269 	if (num_ports + 1  < port->id)
270 		return 0;
271 
272 	snd_hdac_codec_write(hdev, port->pin->nid, 0,
273 			AC_VERB_SET_DEVICE_SEL, port->id);
274 
275 	if (port->id != hdac_hdmi_port_select_get(hdev, port))
276 		return -EIO;
277 
278 	dev_dbg(&hdev->dev, "Selected the port=%d\n", port->id);
279 
280 	return 0;
281 }
282 
get_hdmi_pcm_from_id(struct hdac_hdmi_priv * hdmi,int pcm_idx)283 static struct hdac_hdmi_pcm *get_hdmi_pcm_from_id(struct hdac_hdmi_priv *hdmi,
284 						int pcm_idx)
285 {
286 	struct hdac_hdmi_pcm *pcm;
287 
288 	list_for_each_entry(pcm, &hdmi->pcm_list, head) {
289 		if (pcm->pcm_id == pcm_idx)
290 			return pcm;
291 	}
292 
293 	return NULL;
294 }
295 
sad_format(const u8 * sad)296 static unsigned int sad_format(const u8 *sad)
297 {
298 	return ((sad[0] >> 0x3) & 0x1f);
299 }
300 
sad_sample_bits_lpcm(const u8 * sad)301 static unsigned int sad_sample_bits_lpcm(const u8 *sad)
302 {
303 	return (sad[2] & 7);
304 }
305 
hdac_hdmi_eld_limit_formats(struct snd_pcm_runtime * runtime,void * eld)306 static int hdac_hdmi_eld_limit_formats(struct snd_pcm_runtime *runtime,
307 						void *eld)
308 {
309 	u64 formats = SNDRV_PCM_FMTBIT_S16;
310 	int i;
311 	const u8 *sad, *eld_buf = eld;
312 
313 	sad = drm_eld_sad(eld_buf);
314 	if (!sad)
315 		goto format_constraint;
316 
317 	for (i = drm_eld_sad_count(eld_buf); i > 0; i--, sad += 3) {
318 		if (sad_format(sad) == 1) { /* AUDIO_CODING_TYPE_LPCM */
319 
320 			/*
321 			 * the controller support 20 and 24 bits in 32 bit
322 			 * container so we set S32
323 			 */
324 			if (sad_sample_bits_lpcm(sad) & 0x6)
325 				formats |= SNDRV_PCM_FMTBIT_S32;
326 		}
327 	}
328 
329 format_constraint:
330 	return snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT,
331 				formats);
332 
333 }
334 
335 static void
hdac_hdmi_set_dip_index(struct hdac_device * hdev,hda_nid_t pin_nid,int packet_index,int byte_index)336 hdac_hdmi_set_dip_index(struct hdac_device *hdev, hda_nid_t pin_nid,
337 				int packet_index, int byte_index)
338 {
339 	int val;
340 
341 	val = (packet_index << 5) | (byte_index & 0x1f);
342 	snd_hdac_codec_write(hdev, pin_nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val);
343 }
344 
345 struct dp_audio_infoframe {
346 	u8 type; /* 0x84 */
347 	u8 len;  /* 0x1b */
348 	u8 ver;  /* 0x11 << 2 */
349 
350 	u8 CC02_CT47;	/* match with HDMI infoframe from this on */
351 	u8 SS01_SF24;
352 	u8 CXT04;
353 	u8 CA;
354 	u8 LFEPBL01_LSV36_DM_INH7;
355 };
356 
hdac_hdmi_setup_audio_infoframe(struct hdac_device * hdev,struct hdac_hdmi_pcm * pcm,struct hdac_hdmi_port * port)357 static int hdac_hdmi_setup_audio_infoframe(struct hdac_device *hdev,
358 		   struct hdac_hdmi_pcm *pcm, struct hdac_hdmi_port *port)
359 {
360 	uint8_t buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AUDIO_INFOFRAME_SIZE];
361 	struct hdmi_audio_infoframe frame;
362 	struct hdac_hdmi_pin *pin = port->pin;
363 	struct dp_audio_infoframe dp_ai;
364 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
365 	struct hdac_hdmi_cvt *cvt = pcm->cvt;
366 	u8 *dip;
367 	int ret;
368 	int i;
369 	const u8 *eld_buf;
370 	u8 conn_type;
371 	int channels, ca;
372 
373 	ca = snd_hdac_channel_allocation(hdev, port->eld.info.spk_alloc,
374 			pcm->channels, pcm->chmap_set, true, pcm->chmap);
375 
376 	channels = snd_hdac_get_active_channels(ca);
377 	hdmi->chmap.ops.set_channel_count(hdev, cvt->nid, channels);
378 
379 	snd_hdac_setup_channel_mapping(&hdmi->chmap, pin->nid, false, ca,
380 				pcm->channels, pcm->chmap, pcm->chmap_set);
381 
382 	eld_buf = port->eld.eld_buffer;
383 	conn_type = drm_eld_get_conn_type(eld_buf);
384 
385 	switch (conn_type) {
386 	case DRM_ELD_CONN_TYPE_HDMI:
387 		hdmi_audio_infoframe_init(&frame);
388 
389 		frame.channels = channels;
390 		frame.channel_allocation = ca;
391 
392 		ret = hdmi_audio_infoframe_pack(&frame, buffer, sizeof(buffer));
393 		if (ret < 0)
394 			return ret;
395 
396 		break;
397 
398 	case DRM_ELD_CONN_TYPE_DP:
399 		memset(&dp_ai, 0, sizeof(dp_ai));
400 		dp_ai.type	= 0x84;
401 		dp_ai.len	= 0x1b;
402 		dp_ai.ver	= 0x11 << 2;
403 		dp_ai.CC02_CT47	= channels - 1;
404 		dp_ai.CA	= ca;
405 
406 		dip = (u8 *)&dp_ai;
407 		break;
408 
409 	default:
410 		dev_err(&hdev->dev, "Invalid connection type: %d\n", conn_type);
411 		return -EIO;
412 	}
413 
414 	/* stop infoframe transmission */
415 	hdac_hdmi_set_dip_index(hdev, pin->nid, 0x0, 0x0);
416 	snd_hdac_codec_write(hdev, pin->nid, 0,
417 			AC_VERB_SET_HDMI_DIP_XMIT, AC_DIPXMIT_DISABLE);
418 
419 
420 	/*  Fill infoframe. Index auto-incremented */
421 	hdac_hdmi_set_dip_index(hdev, pin->nid, 0x0, 0x0);
422 	if (conn_type == DRM_ELD_CONN_TYPE_HDMI) {
423 		for (i = 0; i < sizeof(buffer); i++)
424 			snd_hdac_codec_write(hdev, pin->nid, 0,
425 				AC_VERB_SET_HDMI_DIP_DATA, buffer[i]);
426 	} else {
427 		for (i = 0; i < sizeof(dp_ai); i++)
428 			snd_hdac_codec_write(hdev, pin->nid, 0,
429 				AC_VERB_SET_HDMI_DIP_DATA, dip[i]);
430 	}
431 
432 	/* Start infoframe */
433 	hdac_hdmi_set_dip_index(hdev, pin->nid, 0x0, 0x0);
434 	snd_hdac_codec_write(hdev, pin->nid, 0,
435 			AC_VERB_SET_HDMI_DIP_XMIT, AC_DIPXMIT_BEST);
436 
437 	return 0;
438 }
439 
hdac_hdmi_set_stream(struct snd_soc_dai * dai,void * stream,int direction)440 static int hdac_hdmi_set_stream(struct snd_soc_dai *dai,
441 				void *stream, int direction)
442 {
443 	struct hdac_hdmi_priv *hdmi = snd_soc_dai_get_drvdata(dai);
444 	struct hdac_device *hdev = hdmi->hdev;
445 	struct hdac_hdmi_dai_port_map *dai_map;
446 	struct hdac_hdmi_pcm *pcm;
447 	struct hdac_stream *hstream;
448 
449 	if (!stream)
450 		return -EINVAL;
451 
452 	hstream = (struct hdac_stream *)stream;
453 
454 	dev_dbg(&hdev->dev, "%s: strm_tag: %d\n", __func__, hstream->stream_tag);
455 
456 	dai_map = &hdmi->dai_map[dai->id];
457 
458 	pcm = hdac_hdmi_get_pcm_from_cvt(hdmi, dai_map->cvt);
459 
460 	if (pcm)
461 		pcm->stream_tag = (hstream->stream_tag << 4);
462 
463 	return 0;
464 }
465 
hdac_hdmi_set_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * hparams,struct snd_soc_dai * dai)466 static int hdac_hdmi_set_hw_params(struct snd_pcm_substream *substream,
467 	struct snd_pcm_hw_params *hparams, struct snd_soc_dai *dai)
468 {
469 	struct hdac_hdmi_priv *hdmi = snd_soc_dai_get_drvdata(dai);
470 	struct hdac_hdmi_dai_port_map *dai_map;
471 	struct hdac_hdmi_pcm *pcm;
472 	unsigned int bits;
473 	int format;
474 
475 	dai_map = &hdmi->dai_map[dai->id];
476 
477 	bits = snd_hdac_stream_format_bits(params_format(hparams), SNDRV_PCM_SUBFORMAT_STD,
478 					   dai->driver->playback.sig_bits);
479 	format = snd_hdac_stream_format(params_channels(hparams), bits, params_rate(hparams));
480 
481 	pcm = hdac_hdmi_get_pcm_from_cvt(hdmi, dai_map->cvt);
482 	if (!pcm)
483 		return -EIO;
484 
485 	pcm->format = format;
486 	pcm->channels = params_channels(hparams);
487 
488 	return 0;
489 }
490 
hdac_hdmi_query_port_connlist(struct hdac_device * hdev,struct hdac_hdmi_pin * pin,struct hdac_hdmi_port * port)491 static int hdac_hdmi_query_port_connlist(struct hdac_device *hdev,
492 					struct hdac_hdmi_pin *pin,
493 					struct hdac_hdmi_port *port)
494 {
495 	if (!(get_wcaps(hdev, pin->nid) & AC_WCAP_CONN_LIST)) {
496 		dev_warn(&hdev->dev,
497 			"HDMI: pin %d wcaps %#x does not support connection list\n",
498 			pin->nid, get_wcaps(hdev, pin->nid));
499 		return -EINVAL;
500 	}
501 
502 	if (hdac_hdmi_port_select_set(hdev, port) < 0)
503 		return -EIO;
504 
505 	port->num_mux_nids = snd_hdac_get_connections(hdev, pin->nid,
506 			port->mux_nids, HDA_MAX_CONNECTIONS);
507 	if (port->num_mux_nids == 0)
508 		dev_warn(&hdev->dev,
509 			"No connections found for pin:port %d:%d\n",
510 						pin->nid, port->id);
511 
512 	dev_dbg(&hdev->dev, "num_mux_nids %d for pin:port %d:%d\n",
513 			port->num_mux_nids, pin->nid, port->id);
514 
515 	return port->num_mux_nids;
516 }
517 
518 /*
519  * Query pcm list and return port to which stream is routed.
520  *
521  * Also query connection list of the pin, to validate the cvt to port map.
522  *
523  * Same stream rendering to multiple ports simultaneously can be done
524  * possibly, but not supported for now in driver. So return the first port
525  * connected.
526  */
hdac_hdmi_get_port_from_cvt(struct hdac_device * hdev,struct hdac_hdmi_priv * hdmi,struct hdac_hdmi_cvt * cvt)527 static struct hdac_hdmi_port *hdac_hdmi_get_port_from_cvt(
528 			struct hdac_device *hdev,
529 			struct hdac_hdmi_priv *hdmi,
530 			struct hdac_hdmi_cvt *cvt)
531 {
532 	struct hdac_hdmi_pcm *pcm;
533 	struct hdac_hdmi_port *port;
534 	int ret, i;
535 
536 	list_for_each_entry(pcm, &hdmi->pcm_list, head) {
537 		if (pcm->cvt == cvt) {
538 			if (list_empty(&pcm->port_list))
539 				continue;
540 
541 			list_for_each_entry(port, &pcm->port_list, head) {
542 				mutex_lock(&pcm->lock);
543 				ret = hdac_hdmi_query_port_connlist(hdev,
544 							port->pin, port);
545 				mutex_unlock(&pcm->lock);
546 				if (ret < 0)
547 					continue;
548 
549 				for (i = 0; i < port->num_mux_nids; i++) {
550 					if (port->mux_nids[i] == cvt->nid &&
551 						port->eld.monitor_present &&
552 						port->eld.eld_valid)
553 						return port;
554 				}
555 			}
556 		}
557 	}
558 
559 	return NULL;
560 }
561 
562 /*
563  * Go through all converters and ensure connection is set to
564  * the correct pin as set via kcontrols.
565  */
hdac_hdmi_verify_connect_sel_all_pins(struct hdac_device * hdev)566 static void hdac_hdmi_verify_connect_sel_all_pins(struct hdac_device *hdev)
567 {
568 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
569 	struct hdac_hdmi_port *port;
570 	struct hdac_hdmi_cvt *cvt;
571 	int cvt_idx = 0;
572 
573 	list_for_each_entry(cvt, &hdmi->cvt_list, head) {
574 		port = hdac_hdmi_get_port_from_cvt(hdev, hdmi, cvt);
575 		if (port && port->pin) {
576 			snd_hdac_codec_write(hdev, port->pin->nid, 0,
577 					     AC_VERB_SET_CONNECT_SEL, cvt_idx);
578 			dev_dbg(&hdev->dev, "%s: %s set connect %d -> %d\n",
579 				__func__, cvt->name, port->pin->nid, cvt_idx);
580 		}
581 		++cvt_idx;
582 	}
583 }
584 
585 /*
586  * This tries to get a valid pin and set the HW constraints based on the
587  * ELD. Even if a valid pin is not found return success so that device open
588  * doesn't fail.
589  */
hdac_hdmi_pcm_open(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)590 static int hdac_hdmi_pcm_open(struct snd_pcm_substream *substream,
591 			struct snd_soc_dai *dai)
592 {
593 	struct hdac_hdmi_priv *hdmi = snd_soc_dai_get_drvdata(dai);
594 	struct hdac_device *hdev = hdmi->hdev;
595 	struct hdac_hdmi_dai_port_map *dai_map;
596 	struct hdac_hdmi_cvt *cvt;
597 	struct hdac_hdmi_port *port;
598 	int ret;
599 
600 	dai_map = &hdmi->dai_map[dai->id];
601 
602 	cvt = dai_map->cvt;
603 	port = hdac_hdmi_get_port_from_cvt(hdev, hdmi, cvt);
604 
605 	/*
606 	 * To make PA and other userland happy.
607 	 * userland scans devices so returning error does not help.
608 	 */
609 	if (!port)
610 		return 0;
611 	if ((!port->eld.monitor_present) ||
612 			(!port->eld.eld_valid)) {
613 
614 		dev_warn(&hdev->dev,
615 			"Failed: present?:%d ELD valid?:%d pin:port: %d:%d\n",
616 			port->eld.monitor_present, port->eld.eld_valid,
617 			port->pin->nid, port->id);
618 
619 		return 0;
620 	}
621 
622 	dai_map->port = port;
623 
624 	ret = hdac_hdmi_eld_limit_formats(substream->runtime,
625 				port->eld.eld_buffer);
626 	if (ret < 0)
627 		return ret;
628 
629 	return snd_pcm_hw_constraint_eld(substream->runtime,
630 				port->eld.eld_buffer);
631 }
632 
hdac_hdmi_pcm_close(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)633 static void hdac_hdmi_pcm_close(struct snd_pcm_substream *substream,
634 		struct snd_soc_dai *dai)
635 {
636 	struct hdac_hdmi_priv *hdmi = snd_soc_dai_get_drvdata(dai);
637 	struct hdac_hdmi_dai_port_map *dai_map;
638 	struct hdac_hdmi_pcm *pcm;
639 
640 	dai_map = &hdmi->dai_map[dai->id];
641 
642 	pcm = hdac_hdmi_get_pcm_from_cvt(hdmi, dai_map->cvt);
643 
644 	if (pcm) {
645 		mutex_lock(&pcm->lock);
646 		pcm->chmap_set = false;
647 		memset(pcm->chmap, 0, sizeof(pcm->chmap));
648 		pcm->channels = 0;
649 		mutex_unlock(&pcm->lock);
650 	}
651 
652 	if (dai_map->port)
653 		dai_map->port = NULL;
654 }
655 
656 static int
hdac_hdmi_query_cvt_params(struct hdac_device * hdev,struct hdac_hdmi_cvt * cvt)657 hdac_hdmi_query_cvt_params(struct hdac_device *hdev, struct hdac_hdmi_cvt *cvt)
658 {
659 	unsigned int chans;
660 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
661 	int err;
662 
663 	chans = get_wcaps(hdev, cvt->nid);
664 	chans = get_wcaps_channels(chans);
665 
666 	cvt->params.channels_min = 2;
667 
668 	cvt->params.channels_max = chans;
669 	if (chans > hdmi->chmap.channels_max)
670 		hdmi->chmap.channels_max = chans;
671 
672 	err = snd_hdac_query_supported_pcm(hdev, cvt->nid,
673 			&cvt->params.rates,
674 			&cvt->params.formats,
675 			NULL,
676 			&cvt->params.maxbps);
677 	if (err < 0)
678 		dev_err(&hdev->dev,
679 			"Failed to query pcm params for nid %d: %d\n",
680 			cvt->nid, err);
681 
682 	return err;
683 }
684 
hdac_hdmi_fill_widget_info(struct device * dev,struct snd_soc_dapm_widget * w,enum snd_soc_dapm_type id,void * priv,const char * wname,const char * stream,struct snd_kcontrol_new * wc,int numkc,int (* event)(struct snd_soc_dapm_widget *,struct snd_kcontrol *,int),unsigned short event_flags)685 static int hdac_hdmi_fill_widget_info(struct device *dev,
686 		struct snd_soc_dapm_widget *w, enum snd_soc_dapm_type id,
687 		void *priv, const char *wname, const char *stream,
688 		struct snd_kcontrol_new *wc, int numkc,
689 		int (*event)(struct snd_soc_dapm_widget *,
690 		struct snd_kcontrol *, int), unsigned short event_flags)
691 {
692 	w->id = id;
693 	w->name = devm_kstrdup(dev, wname, GFP_KERNEL);
694 	if (!w->name)
695 		return -ENOMEM;
696 
697 	w->sname = stream;
698 	w->reg = SND_SOC_NOPM;
699 	w->shift = 0;
700 	w->kcontrol_news = wc;
701 	w->num_kcontrols = numkc;
702 	w->priv = priv;
703 	w->event = event;
704 	w->event_flags = event_flags;
705 
706 	return 0;
707 }
708 
hdac_hdmi_fill_route(struct snd_soc_dapm_route * route,const char * sink,const char * control,const char * src,int (* handler)(struct snd_soc_dapm_widget * src,struct snd_soc_dapm_widget * sink))709 static void hdac_hdmi_fill_route(struct snd_soc_dapm_route *route,
710 		const char *sink, const char *control, const char *src,
711 		int (*handler)(struct snd_soc_dapm_widget *src,
712 			struct snd_soc_dapm_widget *sink))
713 {
714 	route->sink = sink;
715 	route->source = src;
716 	route->control = control;
717 	route->connected = handler;
718 }
719 
hdac_hdmi_get_pcm(struct hdac_device * hdev,struct hdac_hdmi_port * port)720 static struct hdac_hdmi_pcm *hdac_hdmi_get_pcm(struct hdac_device *hdev,
721 					struct hdac_hdmi_port *port)
722 {
723 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
724 	struct hdac_hdmi_pcm *pcm;
725 	struct hdac_hdmi_port *p;
726 
727 	list_for_each_entry(pcm, &hdmi->pcm_list, head) {
728 		if (list_empty(&pcm->port_list))
729 			continue;
730 
731 		list_for_each_entry(p, &pcm->port_list, head) {
732 			if (p->id == port->id && port->pin == p->pin)
733 				return pcm;
734 		}
735 	}
736 
737 	return NULL;
738 }
739 
hdac_hdmi_set_power_state(struct hdac_device * hdev,hda_nid_t nid,unsigned int pwr_state)740 static void hdac_hdmi_set_power_state(struct hdac_device *hdev,
741 			     hda_nid_t nid, unsigned int pwr_state)
742 {
743 	int count;
744 	unsigned int state;
745 
746 	if (get_wcaps(hdev, nid) & AC_WCAP_POWER) {
747 		if (!snd_hdac_check_power_state(hdev, nid, pwr_state)) {
748 			for (count = 0; count < 10; count++) {
749 				snd_hdac_codec_read(hdev, nid, 0,
750 						AC_VERB_SET_POWER_STATE,
751 						pwr_state);
752 				state = snd_hdac_sync_power_state(hdev,
753 						nid, pwr_state);
754 				if (!(state & AC_PWRST_ERROR))
755 					break;
756 			}
757 		}
758 	}
759 }
760 
hdac_hdmi_set_amp(struct hdac_device * hdev,hda_nid_t nid,int val)761 static void hdac_hdmi_set_amp(struct hdac_device *hdev,
762 				   hda_nid_t nid, int val)
763 {
764 	if (get_wcaps(hdev, nid) & AC_WCAP_OUT_AMP)
765 		snd_hdac_codec_write(hdev, nid, 0,
766 					AC_VERB_SET_AMP_GAIN_MUTE, val);
767 }
768 
769 
hdac_hdmi_pin_output_widget_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kc,int event)770 static int hdac_hdmi_pin_output_widget_event(struct snd_soc_dapm_widget *w,
771 					struct snd_kcontrol *kc, int event)
772 {
773 	struct hdac_hdmi_port *port = w->priv;
774 	struct hdac_device *hdev = dev_to_hdac_dev(w->dapm->dev);
775 	struct hdac_hdmi_pcm *pcm;
776 
777 	dev_dbg(&hdev->dev, "%s: widget: %s event: %x\n",
778 			__func__, w->name, event);
779 
780 	pcm = hdac_hdmi_get_pcm(hdev, port);
781 	if (!pcm)
782 		return -EIO;
783 
784 	/* set the device if pin is mst_capable */
785 	if (hdac_hdmi_port_select_set(hdev, port) < 0)
786 		return -EIO;
787 
788 	switch (event) {
789 	case SND_SOC_DAPM_PRE_PMU:
790 		hdac_hdmi_set_power_state(hdev, port->pin->nid, AC_PWRST_D0);
791 
792 		/* Enable out path for this pin widget */
793 		snd_hdac_codec_write(hdev, port->pin->nid, 0,
794 				AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
795 
796 		hdac_hdmi_set_amp(hdev, port->pin->nid, AMP_OUT_UNMUTE);
797 
798 		return hdac_hdmi_setup_audio_infoframe(hdev, pcm, port);
799 
800 	case SND_SOC_DAPM_POST_PMD:
801 		hdac_hdmi_set_amp(hdev, port->pin->nid, AMP_OUT_MUTE);
802 
803 		/* Disable out path for this pin widget */
804 		snd_hdac_codec_write(hdev, port->pin->nid, 0,
805 				AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
806 
807 		hdac_hdmi_set_power_state(hdev, port->pin->nid, AC_PWRST_D3);
808 		break;
809 
810 	}
811 
812 	return 0;
813 }
814 
hdac_hdmi_cvt_output_widget_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kc,int event)815 static int hdac_hdmi_cvt_output_widget_event(struct snd_soc_dapm_widget *w,
816 					struct snd_kcontrol *kc, int event)
817 {
818 	struct hdac_hdmi_cvt *cvt = w->priv;
819 	struct hdac_device *hdev = dev_to_hdac_dev(w->dapm->dev);
820 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
821 	struct hdac_hdmi_pcm *pcm;
822 
823 	dev_dbg(&hdev->dev, "%s: widget: %s event: %x\n",
824 			__func__, w->name, event);
825 
826 	pcm = hdac_hdmi_get_pcm_from_cvt(hdmi, cvt);
827 	if (!pcm)
828 		return -EIO;
829 
830 	switch (event) {
831 	case SND_SOC_DAPM_PRE_PMU:
832 		hdac_hdmi_set_power_state(hdev, cvt->nid, AC_PWRST_D0);
833 
834 		/* Enable transmission */
835 		snd_hdac_codec_write(hdev, cvt->nid, 0,
836 			AC_VERB_SET_DIGI_CONVERT_1, 1);
837 
838 		/* Category Code (CC) to zero */
839 		snd_hdac_codec_write(hdev, cvt->nid, 0,
840 			AC_VERB_SET_DIGI_CONVERT_2, 0);
841 
842 		snd_hdac_codec_write(hdev, cvt->nid, 0,
843 				AC_VERB_SET_CHANNEL_STREAMID, pcm->stream_tag);
844 		snd_hdac_codec_write(hdev, cvt->nid, 0,
845 				AC_VERB_SET_STREAM_FORMAT, pcm->format);
846 
847 		/*
848 		 * The connection indices are shared by all converters and
849 		 * may interfere with each other. Ensure correct
850 		 * routing for all converters at stream start.
851 		 */
852 		hdac_hdmi_verify_connect_sel_all_pins(hdev);
853 
854 		break;
855 
856 	case SND_SOC_DAPM_POST_PMD:
857 		snd_hdac_codec_write(hdev, cvt->nid, 0,
858 				AC_VERB_SET_CHANNEL_STREAMID, 0);
859 		snd_hdac_codec_write(hdev, cvt->nid, 0,
860 				AC_VERB_SET_STREAM_FORMAT, 0);
861 
862 		hdac_hdmi_set_power_state(hdev, cvt->nid, AC_PWRST_D3);
863 		break;
864 
865 	}
866 
867 	return 0;
868 }
869 
hdac_hdmi_pin_mux_widget_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kc,int event)870 static int hdac_hdmi_pin_mux_widget_event(struct snd_soc_dapm_widget *w,
871 					struct snd_kcontrol *kc, int event)
872 {
873 	struct hdac_hdmi_port *port = w->priv;
874 	struct hdac_device *hdev = dev_to_hdac_dev(w->dapm->dev);
875 	int mux_idx;
876 
877 	dev_dbg(&hdev->dev, "%s: widget: %s event: %x\n",
878 			__func__, w->name, event);
879 
880 	if (!kc)
881 		kc  = w->kcontrols[0];
882 
883 	mux_idx = dapm_kcontrol_get_value(kc);
884 
885 	/* set the device if pin is mst_capable */
886 	if (hdac_hdmi_port_select_set(hdev, port) < 0)
887 		return -EIO;
888 
889 	if (mux_idx > 0) {
890 		snd_hdac_codec_write(hdev, port->pin->nid, 0,
891 			AC_VERB_SET_CONNECT_SEL, (mux_idx - 1));
892 	}
893 
894 	return 0;
895 }
896 
897 /*
898  * Based on user selection, map the PINs with the PCMs.
899  */
hdac_hdmi_set_pin_port_mux(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)900 static int hdac_hdmi_set_pin_port_mux(struct snd_kcontrol *kcontrol,
901 		struct snd_ctl_elem_value *ucontrol)
902 {
903 	int ret;
904 	struct hdac_hdmi_port *p, *p_next;
905 	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
906 	struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
907 	struct snd_soc_dapm_context *dapm = w->dapm;
908 	struct hdac_hdmi_port *port = w->priv;
909 	struct hdac_device *hdev = dev_to_hdac_dev(dapm->dev);
910 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
911 	struct hdac_hdmi_pcm *pcm;
912 	const char *cvt_name =  e->texts[ucontrol->value.enumerated.item[0]];
913 
914 	ret = snd_soc_dapm_put_enum_double(kcontrol, ucontrol);
915 	if (ret < 0)
916 		return ret;
917 
918 	if (port == NULL)
919 		return -EINVAL;
920 
921 	mutex_lock(&hdmi->pin_mutex);
922 	list_for_each_entry(pcm, &hdmi->pcm_list, head) {
923 		if (list_empty(&pcm->port_list))
924 			continue;
925 
926 		list_for_each_entry_safe(p, p_next, &pcm->port_list, head) {
927 			if (p == port && p->id == port->id &&
928 					p->pin == port->pin) {
929 				hdac_hdmi_jack_report_sync(pcm, port, false);
930 				list_del(&p->head);
931 			}
932 		}
933 	}
934 
935 	/*
936 	 * Jack status is not reported during device probe as the
937 	 * PCMs are not registered by then. So report it here.
938 	 */
939 	list_for_each_entry(pcm, &hdmi->pcm_list, head) {
940 		if (!strcmp(cvt_name, pcm->cvt->name)) {
941 			list_add_tail(&port->head, &pcm->port_list);
942 			if (port->eld.monitor_present && port->eld.eld_valid) {
943 				hdac_hdmi_jack_report_sync(pcm, port, true);
944 				mutex_unlock(&hdmi->pin_mutex);
945 				return ret;
946 			}
947 		}
948 	}
949 	mutex_unlock(&hdmi->pin_mutex);
950 
951 	return ret;
952 }
953 
954 /*
955  * Ideally the Mux inputs should be based on the num_muxs enumerated, but
956  * the display driver seem to be programming the connection list for the pin
957  * widget runtime.
958  *
959  * So programming all the possible inputs for the mux, the user has to take
960  * care of selecting the right one and leaving all other inputs selected to
961  * "NONE"
962  */
hdac_hdmi_create_pin_port_muxs(struct hdac_device * hdev,struct hdac_hdmi_port * port,struct snd_soc_dapm_widget * widget,const char * widget_name)963 static int hdac_hdmi_create_pin_port_muxs(struct hdac_device *hdev,
964 				struct hdac_hdmi_port *port,
965 				struct snd_soc_dapm_widget *widget,
966 				const char *widget_name)
967 {
968 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
969 	struct hdac_hdmi_pin *pin = port->pin;
970 	struct snd_kcontrol_new *kc;
971 	struct hdac_hdmi_cvt *cvt;
972 	struct soc_enum *se;
973 	char kc_name[NAME_SIZE];
974 	char mux_items[NAME_SIZE];
975 	/* To hold inputs to the Pin mux */
976 	char *items[HDA_MAX_CONNECTIONS];
977 	int i = 0;
978 	int num_items = hdmi->num_cvt + 1;
979 
980 	kc = devm_kzalloc(&hdev->dev, sizeof(*kc), GFP_KERNEL);
981 	if (!kc)
982 		return -ENOMEM;
983 
984 	se = devm_kzalloc(&hdev->dev, sizeof(*se), GFP_KERNEL);
985 	if (!se)
986 		return -ENOMEM;
987 
988 	snprintf(kc_name, NAME_SIZE, "Pin %d port %d Input",
989 						pin->nid, port->id);
990 	kc->name = devm_kstrdup(&hdev->dev, kc_name, GFP_KERNEL);
991 	if (!kc->name)
992 		return -ENOMEM;
993 
994 	kc->private_value = (long)se;
995 	kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
996 	kc->access = 0;
997 	kc->info = snd_soc_info_enum_double;
998 	kc->put = hdac_hdmi_set_pin_port_mux;
999 	kc->get = snd_soc_dapm_get_enum_double;
1000 
1001 	se->reg = SND_SOC_NOPM;
1002 
1003 	/* enum texts: ["NONE", "cvt #", "cvt #", ...] */
1004 	se->items = num_items;
1005 	se->mask = roundup_pow_of_two(se->items) - 1;
1006 
1007 	sprintf(mux_items, "NONE");
1008 	items[i] = devm_kstrdup(&hdev->dev, mux_items, GFP_KERNEL);
1009 	if (!items[i])
1010 		return -ENOMEM;
1011 
1012 	list_for_each_entry(cvt, &hdmi->cvt_list, head) {
1013 		i++;
1014 		sprintf(mux_items, "cvt %d", cvt->nid);
1015 		items[i] = devm_kstrdup(&hdev->dev, mux_items, GFP_KERNEL);
1016 		if (!items[i])
1017 			return -ENOMEM;
1018 	}
1019 
1020 	se->texts = devm_kmemdup(&hdev->dev, items,
1021 			(num_items  * sizeof(char *)), GFP_KERNEL);
1022 	if (!se->texts)
1023 		return -ENOMEM;
1024 
1025 	return hdac_hdmi_fill_widget_info(&hdev->dev, widget,
1026 			snd_soc_dapm_mux, port, widget_name, NULL, kc, 1,
1027 			hdac_hdmi_pin_mux_widget_event,
1028 			SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_REG);
1029 }
1030 
1031 /* Add cvt <- input <- mux route map */
hdac_hdmi_add_pinmux_cvt_route(struct hdac_device * hdev,struct snd_soc_dapm_widget * widgets,struct snd_soc_dapm_route * route,int rindex)1032 static void hdac_hdmi_add_pinmux_cvt_route(struct hdac_device *hdev,
1033 			struct snd_soc_dapm_widget *widgets,
1034 			struct snd_soc_dapm_route *route, int rindex)
1035 {
1036 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1037 	const struct snd_kcontrol_new *kc;
1038 	struct soc_enum *se;
1039 	int mux_index = hdmi->num_cvt + hdmi->num_ports;
1040 	int i, j;
1041 
1042 	for (i = 0; i < hdmi->num_ports; i++) {
1043 		kc = widgets[mux_index].kcontrol_news;
1044 		se = (struct soc_enum *)kc->private_value;
1045 		for (j = 0; j < hdmi->num_cvt; j++) {
1046 			hdac_hdmi_fill_route(&route[rindex],
1047 					widgets[mux_index].name,
1048 					se->texts[j + 1],
1049 					widgets[j].name, NULL);
1050 
1051 			rindex++;
1052 		}
1053 
1054 		mux_index++;
1055 	}
1056 }
1057 
1058 /*
1059  * Widgets are added in the below sequence
1060  *	Converter widgets for num converters enumerated
1061  *	Pin-port widgets for num ports for Pins enumerated
1062  *	Pin-port mux widgets to represent connenction list of pin widget
1063  *
1064  * For each port, one Mux and One output widget is added
1065  * Total widgets elements = num_cvt + (num_ports * 2);
1066  *
1067  * Routes are added as below:
1068  *	pin-port mux -> pin (based on num_ports)
1069  *	cvt -> "Input sel control" -> pin-port_mux
1070  *
1071  * Total route elements:
1072  *	num_ports + (pin_muxes * num_cvt)
1073  */
create_fill_widget_route_map(struct snd_soc_dapm_context * dapm)1074 static int create_fill_widget_route_map(struct snd_soc_dapm_context *dapm)
1075 {
1076 	struct snd_soc_dapm_widget *widgets;
1077 	struct snd_soc_dapm_route *route;
1078 	struct hdac_device *hdev = dev_to_hdac_dev(dapm->dev);
1079 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1080 	struct snd_soc_dai_driver *dai_drv = hdmi->dai_drv;
1081 	char widget_name[NAME_SIZE];
1082 	struct hdac_hdmi_cvt *cvt;
1083 	struct hdac_hdmi_pin *pin;
1084 	int ret, i = 0, num_routes = 0, j;
1085 
1086 	if (list_empty(&hdmi->cvt_list) || list_empty(&hdmi->pin_list))
1087 		return -EINVAL;
1088 
1089 	widgets = devm_kzalloc(dapm->dev, (sizeof(*widgets) *
1090 				((2 * hdmi->num_ports) + hdmi->num_cvt)),
1091 				GFP_KERNEL);
1092 
1093 	if (!widgets)
1094 		return -ENOMEM;
1095 
1096 	/* DAPM widgets to represent each converter widget */
1097 	list_for_each_entry(cvt, &hdmi->cvt_list, head) {
1098 		sprintf(widget_name, "Converter %d", cvt->nid);
1099 		ret = hdac_hdmi_fill_widget_info(dapm->dev, &widgets[i],
1100 			snd_soc_dapm_aif_in, cvt,
1101 			widget_name, dai_drv[i].playback.stream_name, NULL, 0,
1102 			hdac_hdmi_cvt_output_widget_event,
1103 			SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD);
1104 		if (ret < 0)
1105 			return ret;
1106 		i++;
1107 	}
1108 
1109 	list_for_each_entry(pin, &hdmi->pin_list, head) {
1110 		for (j = 0; j < pin->num_ports; j++) {
1111 			sprintf(widget_name, "hif%d-%d Output",
1112 				pin->nid, pin->ports[j].id);
1113 			ret = hdac_hdmi_fill_widget_info(dapm->dev, &widgets[i],
1114 					snd_soc_dapm_output, &pin->ports[j],
1115 					widget_name, NULL, NULL, 0,
1116 					hdac_hdmi_pin_output_widget_event,
1117 					SND_SOC_DAPM_PRE_PMU |
1118 					SND_SOC_DAPM_POST_PMD);
1119 			if (ret < 0)
1120 				return ret;
1121 			pin->ports[j].output_pin = widgets[i].name;
1122 			i++;
1123 		}
1124 	}
1125 
1126 	/* DAPM widgets to represent the connection list to pin widget */
1127 	list_for_each_entry(pin, &hdmi->pin_list, head) {
1128 		for (j = 0; j < pin->num_ports; j++) {
1129 			sprintf(widget_name, "Pin%d-Port%d Mux",
1130 				pin->nid, pin->ports[j].id);
1131 			ret = hdac_hdmi_create_pin_port_muxs(hdev,
1132 						&pin->ports[j], &widgets[i],
1133 						widget_name);
1134 			if (ret < 0)
1135 				return ret;
1136 			i++;
1137 
1138 			/* For cvt to pin_mux mapping */
1139 			num_routes += hdmi->num_cvt;
1140 
1141 			/* For pin_mux to pin mapping */
1142 			num_routes++;
1143 		}
1144 	}
1145 
1146 	route = devm_kzalloc(dapm->dev, (sizeof(*route) * num_routes),
1147 							GFP_KERNEL);
1148 	if (!route)
1149 		return -ENOMEM;
1150 
1151 	i = 0;
1152 	/* Add pin <- NULL <- mux route map */
1153 	list_for_each_entry(pin, &hdmi->pin_list, head) {
1154 		for (j = 0; j < pin->num_ports; j++) {
1155 			int sink_index = i + hdmi->num_cvt;
1156 			int src_index = sink_index + pin->num_ports *
1157 						hdmi->num_pin;
1158 
1159 			hdac_hdmi_fill_route(&route[i],
1160 				widgets[sink_index].name, NULL,
1161 				widgets[src_index].name, NULL);
1162 			i++;
1163 		}
1164 	}
1165 
1166 	hdac_hdmi_add_pinmux_cvt_route(hdev, widgets, route, i);
1167 
1168 	snd_soc_dapm_new_controls(dapm, widgets,
1169 		((2 * hdmi->num_ports) + hdmi->num_cvt));
1170 
1171 	snd_soc_dapm_add_routes(dapm, route, num_routes);
1172 	snd_soc_dapm_new_widgets(dapm->card);
1173 
1174 	return 0;
1175 
1176 }
1177 
hdac_hdmi_init_dai_map(struct hdac_device * hdev)1178 static int hdac_hdmi_init_dai_map(struct hdac_device *hdev)
1179 {
1180 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1181 	struct hdac_hdmi_dai_port_map *dai_map;
1182 	struct hdac_hdmi_cvt *cvt;
1183 	int dai_id = 0;
1184 
1185 	if (list_empty(&hdmi->cvt_list))
1186 		return -EINVAL;
1187 
1188 	list_for_each_entry(cvt, &hdmi->cvt_list, head) {
1189 		dai_map = &hdmi->dai_map[dai_id];
1190 		dai_map->dai_id = dai_id;
1191 		dai_map->cvt = cvt;
1192 
1193 		dai_id++;
1194 
1195 		if (dai_id == HDA_MAX_CVTS) {
1196 			dev_warn(&hdev->dev,
1197 				"Max dais supported: %d\n", dai_id);
1198 			break;
1199 		}
1200 	}
1201 
1202 	return 0;
1203 }
1204 
hdac_hdmi_add_cvt(struct hdac_device * hdev,hda_nid_t nid)1205 static int hdac_hdmi_add_cvt(struct hdac_device *hdev, hda_nid_t nid)
1206 {
1207 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1208 	struct hdac_hdmi_cvt *cvt;
1209 	char name[NAME_SIZE];
1210 
1211 	cvt = devm_kzalloc(&hdev->dev, sizeof(*cvt), GFP_KERNEL);
1212 	if (!cvt)
1213 		return -ENOMEM;
1214 
1215 	cvt->nid = nid;
1216 	sprintf(name, "cvt %d", cvt->nid);
1217 	cvt->name = devm_kstrdup(&hdev->dev, name, GFP_KERNEL);
1218 	if (!cvt->name)
1219 		return -ENOMEM;
1220 
1221 	list_add_tail(&cvt->head, &hdmi->cvt_list);
1222 	hdmi->num_cvt++;
1223 
1224 	return hdac_hdmi_query_cvt_params(hdev, cvt);
1225 }
1226 
hdac_hdmi_parse_eld(struct hdac_device * hdev,struct hdac_hdmi_port * port)1227 static int hdac_hdmi_parse_eld(struct hdac_device *hdev,
1228 			struct hdac_hdmi_port *port)
1229 {
1230 	unsigned int ver, mnl;
1231 
1232 	ver = (port->eld.eld_buffer[DRM_ELD_VER] & DRM_ELD_VER_MASK)
1233 						>> DRM_ELD_VER_SHIFT;
1234 
1235 	if (ver != ELD_VER_CEA_861D && ver != ELD_VER_PARTIAL) {
1236 		dev_err(&hdev->dev, "HDMI: Unknown ELD version %d\n", ver);
1237 		return -EINVAL;
1238 	}
1239 
1240 	mnl = (port->eld.eld_buffer[DRM_ELD_CEA_EDID_VER_MNL] &
1241 		DRM_ELD_MNL_MASK) >> DRM_ELD_MNL_SHIFT;
1242 
1243 	if (mnl > ELD_MAX_MNL) {
1244 		dev_err(&hdev->dev, "HDMI: MNL Invalid %d\n", mnl);
1245 		return -EINVAL;
1246 	}
1247 
1248 	port->eld.info.spk_alloc = port->eld.eld_buffer[DRM_ELD_SPEAKER];
1249 
1250 	return 0;
1251 }
1252 
hdac_hdmi_present_sense(struct hdac_hdmi_pin * pin,struct hdac_hdmi_port * port)1253 static void hdac_hdmi_present_sense(struct hdac_hdmi_pin *pin,
1254 				    struct hdac_hdmi_port *port)
1255 {
1256 	struct hdac_device *hdev = pin->hdev;
1257 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1258 	struct hdac_hdmi_pcm *pcm;
1259 	int size = 0;
1260 	int port_id = -1;
1261 	bool eld_valid, eld_changed;
1262 
1263 	if (!hdmi)
1264 		return;
1265 
1266 	/*
1267 	 * In case of non MST pin, get_eld info API expectes port
1268 	 * to be -1.
1269 	 */
1270 	mutex_lock(&hdmi->pin_mutex);
1271 	port->eld.monitor_present = false;
1272 
1273 	if (pin->mst_capable)
1274 		port_id = port->id;
1275 
1276 	size = snd_hdac_acomp_get_eld(hdev, pin->nid, port_id,
1277 				&port->eld.monitor_present,
1278 				port->eld.eld_buffer,
1279 				ELD_MAX_SIZE);
1280 
1281 	if (size > 0) {
1282 		size = min(size, ELD_MAX_SIZE);
1283 		if (hdac_hdmi_parse_eld(hdev, port) < 0)
1284 			size = -EINVAL;
1285 	}
1286 
1287 	eld_valid = port->eld.eld_valid;
1288 
1289 	if (size > 0) {
1290 		port->eld.eld_valid = true;
1291 		port->eld.eld_size = size;
1292 	} else {
1293 		port->eld.eld_valid = false;
1294 		port->eld.eld_size = 0;
1295 	}
1296 
1297 	eld_changed = (eld_valid != port->eld.eld_valid);
1298 
1299 	pcm = hdac_hdmi_get_pcm(hdev, port);
1300 
1301 	if (!port->eld.monitor_present || !port->eld.eld_valid) {
1302 
1303 		dev_err(&hdev->dev, "%s: disconnect for pin:port %d:%d\n",
1304 						__func__, pin->nid, port->id);
1305 
1306 		/*
1307 		 * PCMs are not registered during device probe, so don't
1308 		 * report jack here. It will be done in usermode mux
1309 		 * control select.
1310 		 */
1311 		if (pcm) {
1312 			hdac_hdmi_jack_report(pcm, port, false);
1313 			schedule_work(&port->dapm_work);
1314 		}
1315 
1316 		mutex_unlock(&hdmi->pin_mutex);
1317 		return;
1318 	}
1319 
1320 	if (port->eld.monitor_present && port->eld.eld_valid) {
1321 		if (pcm) {
1322 			hdac_hdmi_jack_report(pcm, port, true);
1323 			schedule_work(&port->dapm_work);
1324 		}
1325 
1326 		print_hex_dump_debug("ELD: ", DUMP_PREFIX_OFFSET, 16, 1,
1327 			  port->eld.eld_buffer, port->eld.eld_size, false);
1328 
1329 	}
1330 	mutex_unlock(&hdmi->pin_mutex);
1331 
1332 	if (eld_changed && pcm)
1333 		snd_ctl_notify(hdmi->card,
1334 			       SNDRV_CTL_EVENT_MASK_VALUE |
1335 			       SNDRV_CTL_EVENT_MASK_INFO,
1336 			       &pcm->eld_ctl->id);
1337 }
1338 
hdac_hdmi_add_ports(struct hdac_device * hdev,struct hdac_hdmi_pin * pin)1339 static int hdac_hdmi_add_ports(struct hdac_device *hdev,
1340 			       struct hdac_hdmi_pin *pin)
1341 {
1342 	struct hdac_hdmi_port *ports;
1343 	int max_ports = HDA_MAX_PORTS;
1344 	int i;
1345 
1346 	/*
1347 	 * FIXME: max_port may vary for each platform, so pass this as
1348 	 * as driver data or query from i915 interface when this API is
1349 	 * implemented.
1350 	 */
1351 
1352 	ports = devm_kcalloc(&hdev->dev, max_ports, sizeof(*ports), GFP_KERNEL);
1353 	if (!ports)
1354 		return -ENOMEM;
1355 
1356 	for (i = 0; i < max_ports; i++) {
1357 		ports[i].id = i;
1358 		ports[i].pin = pin;
1359 		INIT_WORK(&ports[i].dapm_work, hdac_hdmi_jack_dapm_work);
1360 	}
1361 	pin->ports = ports;
1362 	pin->num_ports = max_ports;
1363 	return 0;
1364 }
1365 
hdac_hdmi_add_pin(struct hdac_device * hdev,hda_nid_t nid)1366 static int hdac_hdmi_add_pin(struct hdac_device *hdev, hda_nid_t nid)
1367 {
1368 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1369 	struct hdac_hdmi_pin *pin;
1370 	int ret;
1371 
1372 	pin = devm_kzalloc(&hdev->dev, sizeof(*pin), GFP_KERNEL);
1373 	if (!pin)
1374 		return -ENOMEM;
1375 
1376 	pin->nid = nid;
1377 	pin->mst_capable = false;
1378 	pin->hdev = hdev;
1379 	ret = hdac_hdmi_add_ports(hdev, pin);
1380 	if (ret < 0)
1381 		return ret;
1382 
1383 	list_add_tail(&pin->head, &hdmi->pin_list);
1384 	hdmi->num_pin++;
1385 	hdmi->num_ports += pin->num_ports;
1386 
1387 	return 0;
1388 }
1389 
1390 #define INTEL_VENDOR_NID 0x08
1391 #define INTEL_GLK_VENDOR_NID 0x0b
1392 #define INTEL_GET_VENDOR_VERB 0xf81
1393 #define INTEL_SET_VENDOR_VERB 0x781
1394 #define INTEL_EN_DP12			0x02 /* enable DP 1.2 features */
1395 #define INTEL_EN_ALL_PIN_CVTS	0x01 /* enable 2nd & 3rd pins and convertors */
1396 
hdac_hdmi_skl_enable_all_pins(struct hdac_device * hdev)1397 static void hdac_hdmi_skl_enable_all_pins(struct hdac_device *hdev)
1398 {
1399 	unsigned int vendor_param;
1400 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1401 	unsigned int vendor_nid = hdmi->drv_data->vendor_nid;
1402 
1403 	vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1404 				INTEL_GET_VENDOR_VERB, 0);
1405 	if (vendor_param == -1 || vendor_param & INTEL_EN_ALL_PIN_CVTS)
1406 		return;
1407 
1408 	vendor_param |= INTEL_EN_ALL_PIN_CVTS;
1409 	vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1410 				INTEL_SET_VENDOR_VERB, vendor_param);
1411 	if (vendor_param == -1)
1412 		return;
1413 }
1414 
hdac_hdmi_skl_enable_dp12(struct hdac_device * hdev)1415 static void hdac_hdmi_skl_enable_dp12(struct hdac_device *hdev)
1416 {
1417 	unsigned int vendor_param;
1418 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1419 	unsigned int vendor_nid = hdmi->drv_data->vendor_nid;
1420 
1421 	vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1422 				INTEL_GET_VENDOR_VERB, 0);
1423 	if (vendor_param == -1 || vendor_param & INTEL_EN_DP12)
1424 		return;
1425 
1426 	/* enable DP1.2 mode */
1427 	vendor_param |= INTEL_EN_DP12;
1428 	vendor_param = snd_hdac_codec_read(hdev, vendor_nid, 0,
1429 				INTEL_SET_VENDOR_VERB, vendor_param);
1430 	if (vendor_param == -1)
1431 		return;
1432 
1433 }
1434 
hdac_hdmi_eld_ctl_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)1435 static int hdac_hdmi_eld_ctl_info(struct snd_kcontrol *kcontrol,
1436 			     struct snd_ctl_elem_info *uinfo)
1437 {
1438 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
1439 	struct hdac_hdmi_priv *hdmi = snd_soc_component_get_drvdata(component);
1440 	struct hdac_hdmi_pcm *pcm;
1441 	struct hdac_hdmi_port *port;
1442 	struct hdac_hdmi_eld *eld;
1443 
1444 	uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
1445 	uinfo->count = 0;
1446 
1447 	pcm = get_hdmi_pcm_from_id(hdmi, kcontrol->id.device);
1448 	if (!pcm) {
1449 		dev_dbg(component->dev, "%s: no pcm, device %d\n", __func__,
1450 			kcontrol->id.device);
1451 		return 0;
1452 	}
1453 
1454 	if (list_empty(&pcm->port_list)) {
1455 		dev_dbg(component->dev, "%s: empty port list, device %d\n",
1456 			__func__, kcontrol->id.device);
1457 		return 0;
1458 	}
1459 
1460 	mutex_lock(&hdmi->pin_mutex);
1461 
1462 	list_for_each_entry(port, &pcm->port_list, head) {
1463 		eld = &port->eld;
1464 
1465 		if (eld->eld_valid) {
1466 			uinfo->count = eld->eld_size;
1467 			break;
1468 		}
1469 	}
1470 
1471 	mutex_unlock(&hdmi->pin_mutex);
1472 
1473 	return 0;
1474 }
1475 
hdac_hdmi_eld_ctl_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1476 static int hdac_hdmi_eld_ctl_get(struct snd_kcontrol *kcontrol,
1477 			    struct snd_ctl_elem_value *ucontrol)
1478 {
1479 	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
1480 	struct hdac_hdmi_priv *hdmi = snd_soc_component_get_drvdata(component);
1481 	struct hdac_hdmi_pcm *pcm;
1482 	struct hdac_hdmi_port *port;
1483 	struct hdac_hdmi_eld *eld;
1484 
1485 	memset(ucontrol->value.bytes.data, 0, sizeof(ucontrol->value.bytes.data));
1486 
1487 	pcm = get_hdmi_pcm_from_id(hdmi, kcontrol->id.device);
1488 	if (!pcm) {
1489 		dev_dbg(component->dev, "%s: no pcm, device %d\n", __func__,
1490 			kcontrol->id.device);
1491 		return 0;
1492 	}
1493 
1494 	if (list_empty(&pcm->port_list)) {
1495 		dev_dbg(component->dev, "%s: empty port list, device %d\n",
1496 			__func__, kcontrol->id.device);
1497 		return 0;
1498 	}
1499 
1500 	mutex_lock(&hdmi->pin_mutex);
1501 
1502 	list_for_each_entry(port, &pcm->port_list, head) {
1503 		eld = &port->eld;
1504 
1505 		if (!eld->eld_valid)
1506 			continue;
1507 
1508 		if (eld->eld_size > ARRAY_SIZE(ucontrol->value.bytes.data) ||
1509 		    eld->eld_size > ELD_MAX_SIZE) {
1510 			mutex_unlock(&hdmi->pin_mutex);
1511 
1512 			dev_err(component->dev, "%s: buffer too small, device %d eld_size %d\n",
1513 				__func__, kcontrol->id.device, eld->eld_size);
1514 			snd_BUG();
1515 			return -EINVAL;
1516 		}
1517 
1518 		memcpy(ucontrol->value.bytes.data, eld->eld_buffer,
1519 		       eld->eld_size);
1520 		break;
1521 	}
1522 
1523 	mutex_unlock(&hdmi->pin_mutex);
1524 
1525 	return 0;
1526 }
1527 
hdac_hdmi_create_eld_ctl(struct snd_soc_component * component,struct hdac_hdmi_pcm * pcm)1528 static int hdac_hdmi_create_eld_ctl(struct snd_soc_component *component, struct hdac_hdmi_pcm *pcm)
1529 {
1530 	struct snd_kcontrol *kctl;
1531 	struct snd_kcontrol_new hdmi_eld_ctl = {
1532 		.access	= SNDRV_CTL_ELEM_ACCESS_READ |
1533 			  SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1534 		.iface	= SNDRV_CTL_ELEM_IFACE_PCM,
1535 		.name	= "ELD",
1536 		.info	= hdac_hdmi_eld_ctl_info,
1537 		.get	= hdac_hdmi_eld_ctl_get,
1538 		.device	= pcm->pcm_id,
1539 	};
1540 
1541 	/* add ELD ctl with the device number corresponding to the PCM stream */
1542 	kctl = snd_ctl_new1(&hdmi_eld_ctl, component);
1543 	if (!kctl)
1544 		return -ENOMEM;
1545 
1546 	pcm->eld_ctl = kctl;
1547 
1548 	return snd_ctl_add(component->card->snd_card, kctl);
1549 }
1550 
1551 static const struct snd_soc_dai_ops hdmi_dai_ops = {
1552 	.startup = hdac_hdmi_pcm_open,
1553 	.shutdown = hdac_hdmi_pcm_close,
1554 	.hw_params = hdac_hdmi_set_hw_params,
1555 	.set_stream = hdac_hdmi_set_stream,
1556 };
1557 
1558 /*
1559  * Each converter can support a stream independently. So a dai is created
1560  * based on the number of converter queried.
1561  */
hdac_hdmi_create_dais(struct hdac_device * hdev,struct snd_soc_dai_driver ** dais,struct hdac_hdmi_priv * hdmi,int num_dais)1562 static int hdac_hdmi_create_dais(struct hdac_device *hdev,
1563 		struct snd_soc_dai_driver **dais,
1564 		struct hdac_hdmi_priv *hdmi, int num_dais)
1565 {
1566 	struct snd_soc_dai_driver *hdmi_dais;
1567 	struct hdac_hdmi_cvt *cvt;
1568 	char name[NAME_SIZE], dai_name[NAME_SIZE];
1569 	int i = 0;
1570 	u32 rates, bps;
1571 	unsigned int rate_max = 384000, rate_min = 8000;
1572 	u64 formats;
1573 	int ret;
1574 
1575 	hdmi_dais = devm_kzalloc(&hdev->dev,
1576 			(sizeof(*hdmi_dais) * num_dais),
1577 			GFP_KERNEL);
1578 	if (!hdmi_dais)
1579 		return -ENOMEM;
1580 
1581 	list_for_each_entry(cvt, &hdmi->cvt_list, head) {
1582 		ret = snd_hdac_query_supported_pcm(hdev, cvt->nid,
1583 					&rates,	&formats, NULL, &bps);
1584 		if (ret)
1585 			return ret;
1586 
1587 		/* Filter out 44.1, 88.2 and 176.4Khz */
1588 		rates &= ~(SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_88200 |
1589 			   SNDRV_PCM_RATE_176400);
1590 		if (!rates)
1591 			return -EINVAL;
1592 
1593 		sprintf(dai_name, "intel-hdmi-hifi%d", i+1);
1594 		hdmi_dais[i].name = devm_kstrdup(&hdev->dev,
1595 					dai_name, GFP_KERNEL);
1596 
1597 		if (!hdmi_dais[i].name)
1598 			return -ENOMEM;
1599 
1600 		snprintf(name, sizeof(name), "hifi%d", i+1);
1601 		hdmi_dais[i].playback.stream_name =
1602 				devm_kstrdup(&hdev->dev, name, GFP_KERNEL);
1603 		if (!hdmi_dais[i].playback.stream_name)
1604 			return -ENOMEM;
1605 
1606 		/*
1607 		 * Set caps based on capability queried from the converter.
1608 		 * It will be constrained runtime based on ELD queried.
1609 		 */
1610 		hdmi_dais[i].playback.formats = formats;
1611 		hdmi_dais[i].playback.rates = rates;
1612 		hdmi_dais[i].playback.rate_max = rate_max;
1613 		hdmi_dais[i].playback.rate_min = rate_min;
1614 		hdmi_dais[i].playback.channels_min = 2;
1615 		hdmi_dais[i].playback.channels_max = 2;
1616 		hdmi_dais[i].playback.sig_bits = bps;
1617 		hdmi_dais[i].ops = &hdmi_dai_ops;
1618 		i++;
1619 	}
1620 
1621 	*dais = hdmi_dais;
1622 	hdmi->dai_drv = hdmi_dais;
1623 
1624 	return 0;
1625 }
1626 
1627 /*
1628  * Parse all nodes and store the cvt/pin nids in array
1629  * Add one time initialization for pin and cvt widgets
1630  */
hdac_hdmi_parse_and_map_nid(struct hdac_device * hdev,struct snd_soc_dai_driver ** dais,int * num_dais)1631 static int hdac_hdmi_parse_and_map_nid(struct hdac_device *hdev,
1632 		struct snd_soc_dai_driver **dais, int *num_dais)
1633 {
1634 	hda_nid_t nid;
1635 	int i, num_nodes;
1636 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1637 	int ret;
1638 
1639 	hdac_hdmi_skl_enable_all_pins(hdev);
1640 	hdac_hdmi_skl_enable_dp12(hdev);
1641 
1642 	num_nodes = snd_hdac_get_sub_nodes(hdev, hdev->afg, &nid);
1643 	if (!nid || num_nodes <= 0) {
1644 		dev_warn(&hdev->dev, "HDMI: failed to get afg sub nodes\n");
1645 		return -EINVAL;
1646 	}
1647 
1648 	for (i = 0; i < num_nodes; i++, nid++) {
1649 		unsigned int caps;
1650 		unsigned int type;
1651 
1652 		caps = get_wcaps(hdev, nid);
1653 		type = get_wcaps_type(caps);
1654 
1655 		if (!(caps & AC_WCAP_DIGITAL))
1656 			continue;
1657 
1658 		switch (type) {
1659 
1660 		case AC_WID_AUD_OUT:
1661 			ret = hdac_hdmi_add_cvt(hdev, nid);
1662 			if (ret < 0)
1663 				return ret;
1664 			break;
1665 
1666 		case AC_WID_PIN:
1667 			ret = hdac_hdmi_add_pin(hdev, nid);
1668 			if (ret < 0)
1669 				return ret;
1670 			break;
1671 		}
1672 	}
1673 
1674 	if (!hdmi->num_pin || !hdmi->num_cvt) {
1675 		ret = -EIO;
1676 		dev_err(&hdev->dev, "Bad pin/cvt setup in %s\n", __func__);
1677 		return ret;
1678 	}
1679 
1680 	ret = hdac_hdmi_create_dais(hdev, dais, hdmi, hdmi->num_cvt);
1681 	if (ret) {
1682 		dev_err(&hdev->dev, "Failed to create dais with err: %d\n",
1683 			ret);
1684 		return ret;
1685 	}
1686 
1687 	*num_dais = hdmi->num_cvt;
1688 	ret = hdac_hdmi_init_dai_map(hdev);
1689 	if (ret < 0)
1690 		dev_err(&hdev->dev, "Failed to init DAI map with err: %d\n",
1691 			ret);
1692 	return ret;
1693 }
1694 
hdac_hdmi_pin2port(void * aptr,int pin)1695 static int hdac_hdmi_pin2port(void *aptr, int pin)
1696 {
1697 	return pin - 4; /* map NID 0x05 -> port #1 */
1698 }
1699 
hdac_hdmi_eld_notify_cb(void * aptr,int port,int pipe)1700 static void hdac_hdmi_eld_notify_cb(void *aptr, int port, int pipe)
1701 {
1702 	struct hdac_device *hdev = aptr;
1703 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1704 	struct hdac_hdmi_pin *pin;
1705 	struct hdac_hdmi_port *hport = NULL;
1706 	struct snd_soc_component *component = hdmi->component;
1707 	int i;
1708 
1709 	/* Don't know how this mapping is derived */
1710 	hda_nid_t pin_nid = port + 0x04;
1711 
1712 	dev_dbg(&hdev->dev, "%s: for pin:%d port=%d\n", __func__,
1713 							pin_nid, pipe);
1714 
1715 	/*
1716 	 * skip notification during system suspend (but not in runtime PM);
1717 	 * the state will be updated at resume. Also since the ELD and
1718 	 * connection states are updated in anyway at the end of the resume,
1719 	 * we can skip it when received during PM process.
1720 	 */
1721 	if (snd_power_get_state(component->card->snd_card) !=
1722 			SNDRV_CTL_POWER_D0)
1723 		return;
1724 
1725 	if (atomic_read(&hdev->in_pm))
1726 		return;
1727 
1728 	list_for_each_entry(pin, &hdmi->pin_list, head) {
1729 		if (pin->nid != pin_nid)
1730 			continue;
1731 
1732 		/* In case of non MST pin, pipe is -1 */
1733 		if (pipe == -1) {
1734 			pin->mst_capable = false;
1735 			/* if not MST, default is port[0] */
1736 			hport = &pin->ports[0];
1737 		} else {
1738 			for (i = 0; i < pin->num_ports; i++) {
1739 				pin->mst_capable = true;
1740 				if (pin->ports[i].id == pipe) {
1741 					hport = &pin->ports[i];
1742 					break;
1743 				}
1744 			}
1745 		}
1746 
1747 		if (hport)
1748 			hdac_hdmi_present_sense(pin, hport);
1749 	}
1750 
1751 }
1752 
1753 static struct drm_audio_component_audio_ops aops = {
1754 	.pin2port	= hdac_hdmi_pin2port,
1755 	.pin_eld_notify	= hdac_hdmi_eld_notify_cb,
1756 };
1757 
hdac_hdmi_get_pcm_from_id(struct snd_soc_card * card,int device)1758 static struct snd_pcm *hdac_hdmi_get_pcm_from_id(struct snd_soc_card *card,
1759 						int device)
1760 {
1761 	struct snd_soc_pcm_runtime *rtd;
1762 
1763 	for_each_card_rtds(card, rtd) {
1764 		if (rtd->pcm && (rtd->pcm->device == device))
1765 			return rtd->pcm;
1766 	}
1767 
1768 	return NULL;
1769 }
1770 
1771 /* create jack pin kcontrols */
create_fill_jack_kcontrols(struct snd_soc_card * card,struct hdac_device * hdev)1772 static int create_fill_jack_kcontrols(struct snd_soc_card *card,
1773 				    struct hdac_device *hdev)
1774 {
1775 	struct hdac_hdmi_pin *pin;
1776 	struct snd_kcontrol_new *kc;
1777 	char *name;
1778 	int i = 0, j;
1779 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
1780 	struct snd_soc_component *component = hdmi->component;
1781 
1782 	kc = devm_kcalloc(component->dev, hdmi->num_ports,
1783 				sizeof(*kc), GFP_KERNEL);
1784 
1785 	if (!kc)
1786 		return -ENOMEM;
1787 
1788 	list_for_each_entry(pin, &hdmi->pin_list, head) {
1789 		for (j = 0; j < pin->num_ports; j++) {
1790 			name = devm_kasprintf(component->dev, GFP_KERNEL,
1791 					      "hif%d-%d Jack",
1792 					      pin->nid, pin->ports[j].id);
1793 			if (!name)
1794 				return -ENOMEM;
1795 
1796 			kc[i].name = devm_kasprintf(component->dev, GFP_KERNEL,
1797 						    "%s Switch", name);
1798 			if (!kc[i].name)
1799 				return -ENOMEM;
1800 
1801 			kc[i].private_value = (unsigned long)name;
1802 			kc[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1803 			kc[i].access = 0;
1804 			kc[i].info = snd_soc_dapm_info_pin_switch;
1805 			kc[i].put = snd_soc_dapm_put_pin_switch;
1806 			kc[i].get = snd_soc_dapm_get_pin_switch;
1807 			i++;
1808 		}
1809 	}
1810 
1811 	return snd_soc_add_card_controls(card, kc, i);
1812 }
1813 
hdac_hdmi_jack_port_init(struct snd_soc_component * component,struct snd_soc_dapm_context * dapm)1814 int hdac_hdmi_jack_port_init(struct snd_soc_component *component,
1815 			struct snd_soc_dapm_context *dapm)
1816 {
1817 	struct hdac_hdmi_priv *hdmi = snd_soc_component_get_drvdata(component);
1818 	struct hdac_device *hdev = hdmi->hdev;
1819 	struct hdac_hdmi_pin *pin;
1820 	struct snd_soc_dapm_widget *widgets;
1821 	struct snd_soc_dapm_route *route;
1822 	char w_name[NAME_SIZE];
1823 	int i = 0, j, ret;
1824 
1825 	widgets = devm_kcalloc(dapm->dev, hdmi->num_ports,
1826 				sizeof(*widgets), GFP_KERNEL);
1827 
1828 	if (!widgets)
1829 		return -ENOMEM;
1830 
1831 	route = devm_kcalloc(dapm->dev, hdmi->num_ports,
1832 				sizeof(*route), GFP_KERNEL);
1833 	if (!route)
1834 		return -ENOMEM;
1835 
1836 	/* create Jack DAPM widget */
1837 	list_for_each_entry(pin, &hdmi->pin_list, head) {
1838 		for (j = 0; j < pin->num_ports; j++) {
1839 			snprintf(w_name, sizeof(w_name), "hif%d-%d Jack",
1840 						pin->nid, pin->ports[j].id);
1841 
1842 			ret = hdac_hdmi_fill_widget_info(dapm->dev, &widgets[i],
1843 					snd_soc_dapm_spk, NULL,
1844 					w_name, NULL, NULL, 0, NULL, 0);
1845 			if (ret < 0)
1846 				return ret;
1847 
1848 			pin->ports[j].jack_pin = widgets[i].name;
1849 			pin->ports[j].dapm = dapm;
1850 
1851 			/* add to route from Jack widget to output */
1852 			hdac_hdmi_fill_route(&route[i], pin->ports[j].jack_pin,
1853 					NULL, pin->ports[j].output_pin, NULL);
1854 
1855 			i++;
1856 		}
1857 	}
1858 
1859 	/* Add Route from Jack widget to the output widget */
1860 	ret = snd_soc_dapm_new_controls(dapm, widgets, hdmi->num_ports);
1861 	if (ret < 0)
1862 		return ret;
1863 
1864 	ret = snd_soc_dapm_add_routes(dapm, route, hdmi->num_ports);
1865 	if (ret < 0)
1866 		return ret;
1867 
1868 	ret = snd_soc_dapm_new_widgets(dapm->card);
1869 	if (ret < 0)
1870 		return ret;
1871 
1872 	/* Add Jack Pin switch Kcontrol */
1873 	ret = create_fill_jack_kcontrols(dapm->card, hdev);
1874 
1875 	if (ret < 0)
1876 		return ret;
1877 
1878 	/* default set the Jack Pin switch to OFF */
1879 	list_for_each_entry(pin, &hdmi->pin_list, head) {
1880 		for (j = 0; j < pin->num_ports; j++)
1881 			snd_soc_dapm_disable_pin(pin->ports[j].dapm,
1882 						pin->ports[j].jack_pin);
1883 	}
1884 
1885 	return 0;
1886 }
1887 EXPORT_SYMBOL_GPL(hdac_hdmi_jack_port_init);
1888 
hdac_hdmi_jack_init(struct snd_soc_dai * dai,int device,struct snd_soc_jack * jack)1889 int hdac_hdmi_jack_init(struct snd_soc_dai *dai, int device,
1890 				struct snd_soc_jack *jack)
1891 {
1892 	struct snd_soc_component *component = dai->component;
1893 	struct hdac_hdmi_priv *hdmi = snd_soc_component_get_drvdata(component);
1894 	struct hdac_device *hdev = hdmi->hdev;
1895 	struct hdac_hdmi_pcm *pcm;
1896 	struct snd_pcm *snd_pcm;
1897 	int err;
1898 
1899 	/*
1900 	 * this is a new PCM device, create new pcm and
1901 	 * add to the pcm list
1902 	 */
1903 	pcm = devm_kzalloc(&hdev->dev, sizeof(*pcm), GFP_KERNEL);
1904 	if (!pcm)
1905 		return -ENOMEM;
1906 	pcm->pcm_id = device;
1907 	pcm->cvt = hdmi->dai_map[dai->id].cvt;
1908 	pcm->jack_event = 0;
1909 	pcm->jack = jack;
1910 	mutex_init(&pcm->lock);
1911 	INIT_LIST_HEAD(&pcm->port_list);
1912 	snd_pcm = hdac_hdmi_get_pcm_from_id(dai->component->card, device);
1913 	if (snd_pcm) {
1914 		err = snd_hdac_add_chmap_ctls(snd_pcm, device, &hdmi->chmap);
1915 		if (err < 0) {
1916 			dev_err(&hdev->dev,
1917 				"chmap control add failed with err: %d for pcm: %d\n",
1918 				err, device);
1919 			return err;
1920 		}
1921 	}
1922 
1923 	/* add control for ELD Bytes */
1924 	err = hdac_hdmi_create_eld_ctl(component, pcm);
1925 	if (err < 0) {
1926 		dev_err(&hdev->dev,
1927 			"eld control add failed with err: %d for pcm: %d\n",
1928 			err, device);
1929 		return err;
1930 	}
1931 
1932 	list_add_tail(&pcm->head, &hdmi->pcm_list);
1933 
1934 	return 0;
1935 }
1936 EXPORT_SYMBOL_GPL(hdac_hdmi_jack_init);
1937 
hdac_hdmi_present_sense_all_pins(struct hdac_device * hdev,struct hdac_hdmi_priv * hdmi,bool detect_pin_caps)1938 static void hdac_hdmi_present_sense_all_pins(struct hdac_device *hdev,
1939 			struct hdac_hdmi_priv *hdmi, bool detect_pin_caps)
1940 {
1941 	int i;
1942 	struct hdac_hdmi_pin *pin;
1943 
1944 	list_for_each_entry(pin, &hdmi->pin_list, head) {
1945 		if (detect_pin_caps) {
1946 
1947 			if (hdac_hdmi_get_port_len(hdev, pin->nid)  == 0)
1948 				pin->mst_capable = false;
1949 			else
1950 				pin->mst_capable = true;
1951 		}
1952 
1953 		for (i = 0; i < pin->num_ports; i++) {
1954 			if (!pin->mst_capable && i > 0)
1955 				continue;
1956 
1957 			hdac_hdmi_present_sense(pin, &pin->ports[i]);
1958 		}
1959 	}
1960 }
1961 
hdmi_codec_probe(struct snd_soc_component * component)1962 static int hdmi_codec_probe(struct snd_soc_component *component)
1963 {
1964 	struct hdac_hdmi_priv *hdmi = snd_soc_component_get_drvdata(component);
1965 	struct hdac_device *hdev = hdmi->hdev;
1966 	struct snd_soc_dapm_context *dapm =
1967 		snd_soc_component_get_dapm(component);
1968 	struct hdac_ext_link *hlink;
1969 	int ret;
1970 
1971 	hdmi->component = component;
1972 
1973 	/*
1974 	 * hold the ref while we probe, also no need to drop the ref on
1975 	 * exit, we call pm_runtime_suspend() so that will do for us
1976 	 */
1977 	hlink = snd_hdac_ext_bus_get_hlink_by_name(hdev->bus, dev_name(&hdev->dev));
1978 	if (!hlink) {
1979 		dev_err(&hdev->dev, "hdac link not found\n");
1980 		return -EIO;
1981 	}
1982 
1983 	snd_hdac_ext_bus_link_get(hdev->bus, hlink);
1984 
1985 	ret = create_fill_widget_route_map(dapm);
1986 	if (ret < 0)
1987 		return ret;
1988 
1989 	aops.audio_ptr = hdev;
1990 	ret = snd_hdac_acomp_register_notifier(hdev->bus, &aops);
1991 	if (ret < 0) {
1992 		dev_err(&hdev->dev, "notifier register failed: err: %d\n", ret);
1993 		return ret;
1994 	}
1995 
1996 	hdac_hdmi_present_sense_all_pins(hdev, hdmi, true);
1997 	/* Imp: Store the card pointer in hda_codec */
1998 	hdmi->card = dapm->card->snd_card;
1999 
2000 	/*
2001 	 * Setup a device_link between card device and HDMI codec device.
2002 	 * The card device is the consumer and the HDMI codec device is
2003 	 * the supplier. With this setting, we can make sure that the audio
2004 	 * domain in display power will be always turned on before operating
2005 	 * on the HDMI audio codec registers.
2006 	 * Let's use the flag DL_FLAG_AUTOREMOVE_CONSUMER. This can make
2007 	 * sure the device link is freed when the machine driver is removed.
2008 	 */
2009 	device_link_add(component->card->dev, &hdev->dev, DL_FLAG_RPM_ACTIVE |
2010 			DL_FLAG_AUTOREMOVE_CONSUMER);
2011 	/*
2012 	 * hdac_device core already sets the state to active and calls
2013 	 * get_noresume. So enable runtime and set the device to suspend.
2014 	 */
2015 	pm_runtime_enable(&hdev->dev);
2016 	pm_runtime_put(&hdev->dev);
2017 	pm_runtime_suspend(&hdev->dev);
2018 
2019 	return 0;
2020 }
2021 
hdmi_codec_remove(struct snd_soc_component * component)2022 static void hdmi_codec_remove(struct snd_soc_component *component)
2023 {
2024 	struct hdac_hdmi_priv *hdmi = snd_soc_component_get_drvdata(component);
2025 	struct hdac_device *hdev = hdmi->hdev;
2026 	int ret;
2027 
2028 	ret = snd_hdac_acomp_register_notifier(hdev->bus, NULL);
2029 	if (ret < 0)
2030 		dev_err(&hdev->dev, "notifier unregister failed: err: %d\n",
2031 				ret);
2032 
2033 	pm_runtime_disable(&hdev->dev);
2034 }
2035 
2036 #ifdef CONFIG_PM_SLEEP
hdmi_codec_resume(struct device * dev)2037 static int hdmi_codec_resume(struct device *dev)
2038 {
2039 	struct hdac_device *hdev = dev_to_hdac_dev(dev);
2040 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
2041 	int ret;
2042 
2043 	ret = pm_runtime_force_resume(dev);
2044 	if (ret < 0)
2045 		return ret;
2046 	/*
2047 	 * As the ELD notify callback request is not entertained while the
2048 	 * device is in suspend state. Need to manually check detection of
2049 	 * all pins here. pin capablity change is not support, so use the
2050 	 * already set pin caps.
2051 	 *
2052 	 * NOTE: this is safe to call even if the codec doesn't actually resume.
2053 	 * The pin check involves only with DRM audio component hooks, so it
2054 	 * works even if the HD-audio side is still dreaming peacefully.
2055 	 */
2056 	hdac_hdmi_present_sense_all_pins(hdev, hdmi, false);
2057 	return 0;
2058 }
2059 #else
2060 #define hdmi_codec_resume NULL
2061 #endif
2062 
2063 static const struct snd_soc_component_driver hdmi_hda_codec = {
2064 	.probe			= hdmi_codec_probe,
2065 	.remove			= hdmi_codec_remove,
2066 	.use_pmdown_time	= 1,
2067 	.endianness		= 1,
2068 };
2069 
hdac_hdmi_get_chmap(struct hdac_device * hdev,int pcm_idx,unsigned char * chmap)2070 static void hdac_hdmi_get_chmap(struct hdac_device *hdev, int pcm_idx,
2071 					unsigned char *chmap)
2072 {
2073 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
2074 	struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
2075 
2076 	memcpy(chmap, pcm->chmap, ARRAY_SIZE(pcm->chmap));
2077 }
2078 
hdac_hdmi_set_chmap(struct hdac_device * hdev,int pcm_idx,unsigned char * chmap,int prepared)2079 static void hdac_hdmi_set_chmap(struct hdac_device *hdev, int pcm_idx,
2080 				unsigned char *chmap, int prepared)
2081 {
2082 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
2083 	struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
2084 	struct hdac_hdmi_port *port;
2085 
2086 	if (!pcm)
2087 		return;
2088 
2089 	if (list_empty(&pcm->port_list))
2090 		return;
2091 
2092 	mutex_lock(&pcm->lock);
2093 	pcm->chmap_set = true;
2094 	memcpy(pcm->chmap, chmap, ARRAY_SIZE(pcm->chmap));
2095 	list_for_each_entry(port, &pcm->port_list, head)
2096 		if (prepared)
2097 			hdac_hdmi_setup_audio_infoframe(hdev, pcm, port);
2098 	mutex_unlock(&pcm->lock);
2099 }
2100 
is_hdac_hdmi_pcm_attached(struct hdac_device * hdev,int pcm_idx)2101 static bool is_hdac_hdmi_pcm_attached(struct hdac_device *hdev, int pcm_idx)
2102 {
2103 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
2104 	struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
2105 
2106 	if (!pcm)
2107 		return false;
2108 
2109 	if (list_empty(&pcm->port_list))
2110 		return false;
2111 
2112 	return true;
2113 }
2114 
hdac_hdmi_get_spk_alloc(struct hdac_device * hdev,int pcm_idx)2115 static int hdac_hdmi_get_spk_alloc(struct hdac_device *hdev, int pcm_idx)
2116 {
2117 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
2118 	struct hdac_hdmi_pcm *pcm = get_hdmi_pcm_from_id(hdmi, pcm_idx);
2119 	struct hdac_hdmi_port *port;
2120 
2121 	if (!pcm)
2122 		return 0;
2123 
2124 	if (list_empty(&pcm->port_list))
2125 		return 0;
2126 
2127 	port = list_first_entry(&pcm->port_list, struct hdac_hdmi_port, head);
2128 
2129 	if (!port || !port->eld.eld_valid)
2130 		return 0;
2131 
2132 	return port->eld.info.spk_alloc;
2133 }
2134 
2135 static struct hdac_hdmi_drv_data intel_glk_drv_data  = {
2136 	.vendor_nid = INTEL_GLK_VENDOR_NID,
2137 };
2138 
2139 static struct hdac_hdmi_drv_data intel_drv_data  = {
2140 	.vendor_nid = INTEL_VENDOR_NID,
2141 };
2142 
hdac_hdmi_dev_probe(struct hdac_device * hdev)2143 static int hdac_hdmi_dev_probe(struct hdac_device *hdev)
2144 {
2145 	struct hdac_hdmi_priv *hdmi_priv;
2146 	struct snd_soc_dai_driver *hdmi_dais = NULL;
2147 	struct hdac_ext_link *hlink;
2148 	int num_dais = 0;
2149 	int ret;
2150 	struct hdac_driver *hdrv = drv_to_hdac_driver(hdev->dev.driver);
2151 	const struct hda_device_id *hdac_id = hdac_get_device_id(hdev, hdrv);
2152 
2153 	/* hold the ref while we probe */
2154 	hlink = snd_hdac_ext_bus_get_hlink_by_name(hdev->bus, dev_name(&hdev->dev));
2155 	if (!hlink) {
2156 		dev_err(&hdev->dev, "hdac link not found\n");
2157 		return -EIO;
2158 	}
2159 
2160 	snd_hdac_ext_bus_link_get(hdev->bus, hlink);
2161 
2162 	hdmi_priv = devm_kzalloc(&hdev->dev, sizeof(*hdmi_priv), GFP_KERNEL);
2163 	if (hdmi_priv == NULL)
2164 		return -ENOMEM;
2165 
2166 	snd_hdac_register_chmap_ops(hdev, &hdmi_priv->chmap);
2167 	hdmi_priv->chmap.ops.get_chmap = hdac_hdmi_get_chmap;
2168 	hdmi_priv->chmap.ops.set_chmap = hdac_hdmi_set_chmap;
2169 	hdmi_priv->chmap.ops.is_pcm_attached = is_hdac_hdmi_pcm_attached;
2170 	hdmi_priv->chmap.ops.get_spk_alloc = hdac_hdmi_get_spk_alloc;
2171 	hdmi_priv->hdev = hdev;
2172 
2173 	if (!hdac_id)
2174 		return -ENODEV;
2175 
2176 	if (hdac_id->driver_data)
2177 		hdmi_priv->drv_data =
2178 			(struct hdac_hdmi_drv_data *)hdac_id->driver_data;
2179 	else
2180 		hdmi_priv->drv_data = &intel_drv_data;
2181 
2182 	dev_set_drvdata(&hdev->dev, hdmi_priv);
2183 
2184 	INIT_LIST_HEAD(&hdmi_priv->pin_list);
2185 	INIT_LIST_HEAD(&hdmi_priv->cvt_list);
2186 	INIT_LIST_HEAD(&hdmi_priv->pcm_list);
2187 	mutex_init(&hdmi_priv->pin_mutex);
2188 
2189 	/*
2190 	 * Turned off in the runtime_suspend during the first explicit
2191 	 * pm_runtime_suspend call.
2192 	 */
2193 	snd_hdac_display_power(hdev->bus, hdev->addr, true);
2194 
2195 	ret = hdac_hdmi_parse_and_map_nid(hdev, &hdmi_dais, &num_dais);
2196 	if (ret < 0) {
2197 		dev_err(&hdev->dev,
2198 			"Failed in parse and map nid with err: %d\n", ret);
2199 		return ret;
2200 	}
2201 	snd_hdac_refresh_widgets(hdev);
2202 
2203 	/* ASoC specific initialization */
2204 	ret = devm_snd_soc_register_component(&hdev->dev, &hdmi_hda_codec,
2205 					hdmi_dais, num_dais);
2206 
2207 	snd_hdac_ext_bus_link_put(hdev->bus, hlink);
2208 
2209 	return ret;
2210 }
2211 
clear_dapm_works(struct hdac_device * hdev)2212 static void clear_dapm_works(struct hdac_device *hdev)
2213 {
2214 	struct hdac_hdmi_priv *hdmi = hdev_to_hdmi_priv(hdev);
2215 	struct hdac_hdmi_pin *pin;
2216 	int i;
2217 
2218 	list_for_each_entry(pin, &hdmi->pin_list, head)
2219 		for (i = 0; i < pin->num_ports; i++)
2220 			cancel_work_sync(&pin->ports[i].dapm_work);
2221 }
2222 
hdac_hdmi_dev_remove(struct hdac_device * hdev)2223 static int hdac_hdmi_dev_remove(struct hdac_device *hdev)
2224 {
2225 	clear_dapm_works(hdev);
2226 	snd_hdac_display_power(hdev->bus, hdev->addr, false);
2227 
2228 	return 0;
2229 }
2230 
2231 #ifdef CONFIG_PM
hdac_hdmi_runtime_suspend(struct device * dev)2232 static int hdac_hdmi_runtime_suspend(struct device *dev)
2233 {
2234 	struct hdac_device *hdev = dev_to_hdac_dev(dev);
2235 	struct hdac_bus *bus = hdev->bus;
2236 	struct hdac_ext_link *hlink;
2237 
2238 	dev_dbg(dev, "Enter: %s\n", __func__);
2239 
2240 	/* controller may not have been initialized for the first time */
2241 	if (!bus)
2242 		return 0;
2243 
2244 	/*
2245 	 * Power down afg.
2246 	 * codec_read is preferred over codec_write to set the power state.
2247 	 * This way verb is send to set the power state and response
2248 	 * is received. So setting power state is ensured without using loop
2249 	 * to read the state.
2250 	 */
2251 	snd_hdac_codec_read(hdev, hdev->afg, 0,	AC_VERB_SET_POWER_STATE,
2252 							AC_PWRST_D3);
2253 
2254 	hlink = snd_hdac_ext_bus_get_hlink_by_name(bus, dev_name(dev));
2255 	if (!hlink) {
2256 		dev_err(dev, "hdac link not found\n");
2257 		return -EIO;
2258 	}
2259 
2260 	snd_hdac_codec_link_down(hdev);
2261 	snd_hdac_ext_bus_link_put(bus, hlink);
2262 
2263 	snd_hdac_display_power(bus, hdev->addr, false);
2264 
2265 	return 0;
2266 }
2267 
hdac_hdmi_runtime_resume(struct device * dev)2268 static int hdac_hdmi_runtime_resume(struct device *dev)
2269 {
2270 	struct hdac_device *hdev = dev_to_hdac_dev(dev);
2271 	struct hdac_bus *bus = hdev->bus;
2272 	struct hdac_ext_link *hlink;
2273 
2274 	dev_dbg(dev, "Enter: %s\n", __func__);
2275 
2276 	/* controller may not have been initialized for the first time */
2277 	if (!bus)
2278 		return 0;
2279 
2280 	hlink = snd_hdac_ext_bus_get_hlink_by_name(bus, dev_name(dev));
2281 	if (!hlink) {
2282 		dev_err(dev, "hdac link not found\n");
2283 		return -EIO;
2284 	}
2285 
2286 	snd_hdac_ext_bus_link_get(bus, hlink);
2287 	snd_hdac_codec_link_up(hdev);
2288 
2289 	snd_hdac_display_power(bus, hdev->addr, true);
2290 
2291 	hdac_hdmi_skl_enable_all_pins(hdev);
2292 	hdac_hdmi_skl_enable_dp12(hdev);
2293 
2294 	/* Power up afg */
2295 	snd_hdac_codec_read(hdev, hdev->afg, 0,	AC_VERB_SET_POWER_STATE,
2296 							AC_PWRST_D0);
2297 
2298 	return 0;
2299 }
2300 #else
2301 #define hdac_hdmi_runtime_suspend NULL
2302 #define hdac_hdmi_runtime_resume NULL
2303 #endif
2304 
2305 static const struct dev_pm_ops hdac_hdmi_pm = {
2306 	SET_RUNTIME_PM_OPS(hdac_hdmi_runtime_suspend, hdac_hdmi_runtime_resume, NULL)
2307 	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, hdmi_codec_resume)
2308 };
2309 
2310 static const struct hda_device_id hdmi_list[] = {
2311 	HDA_CODEC_EXT_ENTRY(0x80862809, 0x100000, "Skylake HDMI", 0),
2312 	HDA_CODEC_EXT_ENTRY(0x8086280a, 0x100000, "Broxton HDMI", 0),
2313 	HDA_CODEC_EXT_ENTRY(0x8086280b, 0x100000, "Kabylake HDMI", 0),
2314 	HDA_CODEC_EXT_ENTRY(0x8086280c, 0x100000, "Cannonlake HDMI",
2315 						   &intel_glk_drv_data),
2316 	HDA_CODEC_EXT_ENTRY(0x8086280d, 0x100000, "Geminilake HDMI",
2317 						   &intel_glk_drv_data),
2318 	{}
2319 };
2320 
2321 MODULE_DEVICE_TABLE(hdaudio, hdmi_list);
2322 
2323 static struct hdac_driver hdmi_driver = {
2324 	.driver = {
2325 		.name   = "HDMI HDA Codec",
2326 		.pm = &hdac_hdmi_pm,
2327 	},
2328 	.id_table       = hdmi_list,
2329 	.probe          = hdac_hdmi_dev_probe,
2330 	.remove         = hdac_hdmi_dev_remove,
2331 };
2332 
hdmi_init(void)2333 static int __init hdmi_init(void)
2334 {
2335 	return snd_hda_ext_driver_register(&hdmi_driver);
2336 }
2337 
hdmi_exit(void)2338 static void __exit hdmi_exit(void)
2339 {
2340 	snd_hda_ext_driver_unregister(&hdmi_driver);
2341 }
2342 
2343 module_init(hdmi_init);
2344 module_exit(hdmi_exit);
2345 
2346 MODULE_LICENSE("GPL v2");
2347 MODULE_DESCRIPTION("HDMI HD codec");
2348 MODULE_AUTHOR("Samreen Nilofer<samreen.nilofer@intel.com>");
2349 MODULE_AUTHOR("Subhransu S. Prusty<subhransu.s.prusty@intel.com>");
2350