2 * hdac_hdmi.c - ASoc HDA-HDMI codec driver for Intel platforms
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 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
18 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
20 #include <linux/init.h>
21 #include <linux/delay.h>
22 #include <linux/module.h>
23 #include <linux/pm_runtime.h>
24 #include <linux/hdmi.h>
25 #include <drm/drm_edid.h>
26 #include <sound/pcm_params.h>
27 #include <sound/jack.h>
28 #include <sound/soc.h>
29 #include <sound/hdaudio_ext.h>
30 #include <sound/hda_i915.h>
31 #include <sound/pcm_drm_eld.h>
32 #include <sound/hda_chmap.h>
33 #include "../../hda/local.h"
34 #include "hdac_hdmi.h"
38 #define AMP_OUT_MUTE 0xb080
39 #define AMP_OUT_UNMUTE 0xb000
40 #define PIN_OUT (AC_PINCTL_OUT_EN)
42 #define HDA_MAX_CONNECTIONS 32
44 #define HDA_MAX_CVTS 3
45 #define HDA_MAX_PORTS 3
47 #define ELD_MAX_SIZE 256
48 #define ELD_FIXED_BYTES 20
50 #define ELD_VER_CEA_861D 2
51 #define ELD_VER_PARTIAL 31
52 #define ELD_MAX_MNL 16
54 struct hdac_hdmi_cvt_params
{
55 unsigned int channels_min
;
56 unsigned int channels_max
;
62 struct hdac_hdmi_cvt
{
63 struct list_head head
;
66 struct hdac_hdmi_cvt_params params
;
69 /* Currently only spk_alloc, more to be added */
70 struct hdac_hdmi_parsed_eld
{
74 struct hdac_hdmi_eld
{
78 char eld_buffer
[ELD_MAX_SIZE
];
79 struct hdac_hdmi_parsed_eld info
;
82 struct hdac_hdmi_pin
{
83 struct list_head head
;
86 struct hdac_hdmi_port
*ports
;
88 struct hdac_ext_device
*edev
;
91 struct hdac_hdmi_port
{
92 struct list_head head
;
94 struct hdac_hdmi_pin
*pin
;
96 hda_nid_t mux_nids
[HDA_MAX_CONNECTIONS
];
97 struct hdac_hdmi_eld eld
;
99 struct snd_soc_dapm_context
*dapm
;
100 const char *output_pin
;
103 struct hdac_hdmi_pcm
{
104 struct list_head head
;
106 struct list_head port_list
;
107 struct hdac_hdmi_cvt
*cvt
;
108 struct snd_soc_jack
*jack
;
113 unsigned char chmap
[8]; /* ALSA API channel-map */
118 struct hdac_hdmi_dai_port_map
{
120 struct hdac_hdmi_port
*port
;
121 struct hdac_hdmi_cvt
*cvt
;
124 struct hdac_hdmi_drv_data
{
125 unsigned int vendor_nid
;
128 struct hdac_hdmi_priv
{
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
;
136 struct mutex pin_mutex
;
137 struct hdac_chmap chmap
;
138 struct hdac_hdmi_drv_data
*drv_data
;
141 static struct hdac_hdmi_pcm
*
142 hdac_hdmi_get_pcm_from_cvt(struct hdac_hdmi_priv
*hdmi
,
143 struct hdac_hdmi_cvt
*cvt
)
145 struct hdac_hdmi_pcm
*pcm
= NULL
;
147 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
155 static void hdac_hdmi_jack_report(struct hdac_hdmi_pcm
*pcm
,
156 struct hdac_hdmi_port
*port
, bool is_connect
)
158 struct hdac_ext_device
*edev
= port
->pin
->edev
;
161 snd_soc_dapm_enable_pin(port
->dapm
, port
->jack_pin
);
163 snd_soc_dapm_disable_pin(port
->dapm
, port
->jack_pin
);
167 * Report Jack connect event when a device is connected
168 * for the first time where same PCM is attached to multiple
171 if (pcm
->jack_event
== 0) {
172 dev_dbg(&edev
->hdac
.dev
,
173 "jack report for pcm=%d\n",
175 snd_soc_jack_report(pcm
->jack
, SND_JACK_AVOUT
,
181 * Report Jack disconnect event when a device is disconnected
182 * is the only last connected device when same PCM is attached
185 if (pcm
->jack_event
== 1)
186 snd_soc_jack_report(pcm
->jack
, 0, SND_JACK_AVOUT
);
187 if (pcm
->jack_event
> 0)
191 snd_soc_dapm_sync(port
->dapm
);
194 /* MST supported verbs */
196 * Get the no devices that can be connected to a port on the Pin widget.
198 static int hdac_hdmi_get_port_len(struct hdac_ext_device
*hdac
, hda_nid_t nid
)
201 unsigned int type
, param
;
203 caps
= get_wcaps(&hdac
->hdac
, nid
);
204 type
= get_wcaps_type(caps
);
206 if (!(caps
& AC_WCAP_DIGITAL
) || (type
!= AC_WID_PIN
))
209 param
= snd_hdac_read_parm_uncached(&hdac
->hdac
, nid
,
214 return param
& AC_DEV_LIST_LEN_MASK
;
218 * Get the port entry select on the pin. Return the port entry
219 * id selected on the pin. Return 0 means the first port entry
220 * is selected or MST is not supported.
222 static int hdac_hdmi_port_select_get(struct hdac_ext_device
*hdac
,
223 struct hdac_hdmi_port
*port
)
225 return snd_hdac_codec_read(&hdac
->hdac
, port
->pin
->nid
,
226 0, AC_VERB_GET_DEVICE_SEL
, 0);
230 * Sets the selected port entry for the configuring Pin widget verb.
231 * returns error if port set is not equal to port get otherwise success
233 static int hdac_hdmi_port_select_set(struct hdac_ext_device
*hdac
,
234 struct hdac_hdmi_port
*port
)
238 if (!port
->pin
->mst_capable
)
241 /* AC_PAR_DEVLIST_LEN is 0 based. */
242 num_ports
= hdac_hdmi_get_port_len(hdac
, port
->pin
->nid
);
247 * Device List Length is a 0 based integer value indicating the
248 * number of sink device that a MST Pin Widget can support.
250 if (num_ports
+ 1 < port
->id
)
253 snd_hdac_codec_write(&hdac
->hdac
, port
->pin
->nid
, 0,
254 AC_VERB_SET_DEVICE_SEL
, port
->id
);
256 if (port
->id
!= hdac_hdmi_port_select_get(hdac
, port
))
259 dev_dbg(&hdac
->hdac
.dev
, "Selected the port=%d\n", port
->id
);
264 static struct hdac_hdmi_pcm
*get_hdmi_pcm_from_id(struct hdac_hdmi_priv
*hdmi
,
267 struct hdac_hdmi_pcm
*pcm
;
269 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
270 if (pcm
->pcm_id
== pcm_idx
)
277 static inline struct hdac_ext_device
*to_hda_ext_device(struct device
*dev
)
279 struct hdac_device
*hdac
= dev_to_hdac_dev(dev
);
281 return to_ehdac_device(hdac
);
284 static unsigned int sad_format(const u8
*sad
)
286 return ((sad
[0] >> 0x3) & 0x1f);
289 static unsigned int sad_sample_bits_lpcm(const u8
*sad
)
294 static int hdac_hdmi_eld_limit_formats(struct snd_pcm_runtime
*runtime
,
297 u64 formats
= SNDRV_PCM_FMTBIT_S16
;
299 const u8
*sad
, *eld_buf
= eld
;
301 sad
= drm_eld_sad(eld_buf
);
303 goto format_constraint
;
305 for (i
= drm_eld_sad_count(eld_buf
); i
> 0; i
--, sad
+= 3) {
306 if (sad_format(sad
) == 1) { /* AUDIO_CODING_TYPE_LPCM */
309 * the controller support 20 and 24 bits in 32 bit
310 * container so we set S32
312 if (sad_sample_bits_lpcm(sad
) & 0x6)
313 formats
|= SNDRV_PCM_FMTBIT_S32
;
318 return snd_pcm_hw_constraint_mask64(runtime
, SNDRV_PCM_HW_PARAM_FORMAT
,
324 hdac_hdmi_set_dip_index(struct hdac_ext_device
*hdac
, hda_nid_t pin_nid
,
325 int packet_index
, int byte_index
)
329 val
= (packet_index
<< 5) | (byte_index
& 0x1f);
331 snd_hdac_codec_write(&hdac
->hdac
, pin_nid
, 0,
332 AC_VERB_SET_HDMI_DIP_INDEX
, val
);
335 struct dp_audio_infoframe
{
338 u8 ver
; /* 0x11 << 2 */
340 u8 CC02_CT47
; /* match with HDMI infoframe from this on */
344 u8 LFEPBL01_LSV36_DM_INH7
;
347 static int hdac_hdmi_setup_audio_infoframe(struct hdac_ext_device
*hdac
,
348 struct hdac_hdmi_pcm
*pcm
, struct hdac_hdmi_port
*port
)
350 uint8_t buffer
[HDMI_INFOFRAME_HEADER_SIZE
+ HDMI_AUDIO_INFOFRAME_SIZE
];
351 struct hdmi_audio_infoframe frame
;
352 struct hdac_hdmi_pin
*pin
= port
->pin
;
353 struct dp_audio_infoframe dp_ai
;
354 struct hdac_hdmi_priv
*hdmi
= hdac
->private_data
;
355 struct hdac_hdmi_cvt
*cvt
= pcm
->cvt
;
363 ca
= snd_hdac_channel_allocation(&hdac
->hdac
, port
->eld
.info
.spk_alloc
,
364 pcm
->channels
, pcm
->chmap_set
, true, pcm
->chmap
);
366 channels
= snd_hdac_get_active_channels(ca
);
367 hdmi
->chmap
.ops
.set_channel_count(&hdac
->hdac
, cvt
->nid
, channels
);
369 snd_hdac_setup_channel_mapping(&hdmi
->chmap
, pin
->nid
, false, ca
,
370 pcm
->channels
, pcm
->chmap
, pcm
->chmap_set
);
372 eld_buf
= port
->eld
.eld_buffer
;
373 conn_type
= drm_eld_get_conn_type(eld_buf
);
376 case DRM_ELD_CONN_TYPE_HDMI
:
377 hdmi_audio_infoframe_init(&frame
);
379 frame
.channels
= channels
;
380 frame
.channel_allocation
= ca
;
382 ret
= hdmi_audio_infoframe_pack(&frame
, buffer
, sizeof(buffer
));
388 case DRM_ELD_CONN_TYPE_DP
:
389 memset(&dp_ai
, 0, sizeof(dp_ai
));
392 dp_ai
.ver
= 0x11 << 2;
393 dp_ai
.CC02_CT47
= channels
- 1;
400 dev_err(&hdac
->hdac
.dev
, "Invalid connection type: %d\n",
405 /* stop infoframe transmission */
406 hdac_hdmi_set_dip_index(hdac
, pin
->nid
, 0x0, 0x0);
407 snd_hdac_codec_write(&hdac
->hdac
, pin
->nid
, 0,
408 AC_VERB_SET_HDMI_DIP_XMIT
, AC_DIPXMIT_DISABLE
);
411 /* Fill infoframe. Index auto-incremented */
412 hdac_hdmi_set_dip_index(hdac
, pin
->nid
, 0x0, 0x0);
413 if (conn_type
== DRM_ELD_CONN_TYPE_HDMI
) {
414 for (i
= 0; i
< sizeof(buffer
); i
++)
415 snd_hdac_codec_write(&hdac
->hdac
, pin
->nid
, 0,
416 AC_VERB_SET_HDMI_DIP_DATA
, buffer
[i
]);
418 for (i
= 0; i
< sizeof(dp_ai
); i
++)
419 snd_hdac_codec_write(&hdac
->hdac
, pin
->nid
, 0,
420 AC_VERB_SET_HDMI_DIP_DATA
, dip
[i
]);
423 /* Start infoframe */
424 hdac_hdmi_set_dip_index(hdac
, pin
->nid
, 0x0, 0x0);
425 snd_hdac_codec_write(&hdac
->hdac
, pin
->nid
, 0,
426 AC_VERB_SET_HDMI_DIP_XMIT
, AC_DIPXMIT_BEST
);
431 static int hdac_hdmi_set_tdm_slot(struct snd_soc_dai
*dai
,
432 unsigned int tx_mask
, unsigned int rx_mask
,
433 int slots
, int slot_width
)
435 struct hdac_ext_device
*edev
= snd_soc_dai_get_drvdata(dai
);
436 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
437 struct hdac_hdmi_dai_port_map
*dai_map
;
438 struct hdac_hdmi_pcm
*pcm
;
440 dev_dbg(&edev
->hdac
.dev
, "%s: strm_tag: %d\n", __func__
, tx_mask
);
442 dai_map
= &hdmi
->dai_map
[dai
->id
];
444 pcm
= hdac_hdmi_get_pcm_from_cvt(hdmi
, dai_map
->cvt
);
447 pcm
->stream_tag
= (tx_mask
<< 4);
452 static int hdac_hdmi_set_hw_params(struct snd_pcm_substream
*substream
,
453 struct snd_pcm_hw_params
*hparams
, struct snd_soc_dai
*dai
)
455 struct hdac_ext_device
*hdac
= snd_soc_dai_get_drvdata(dai
);
456 struct hdac_hdmi_priv
*hdmi
= hdac
->private_data
;
457 struct hdac_hdmi_dai_port_map
*dai_map
;
458 struct hdac_hdmi_port
*port
;
459 struct hdac_hdmi_pcm
*pcm
;
462 dai_map
= &hdmi
->dai_map
[dai
->id
];
463 port
= dai_map
->port
;
468 if ((!port
->eld
.monitor_present
) || (!port
->eld
.eld_valid
)) {
469 dev_err(&hdac
->hdac
.dev
,
470 "device is not configured for this pin:port%d:%d\n",
471 port
->pin
->nid
, port
->id
);
475 format
= snd_hdac_calc_stream_format(params_rate(hparams
),
476 params_channels(hparams
), params_format(hparams
),
477 dai
->driver
->playback
.sig_bits
, 0);
479 pcm
= hdac_hdmi_get_pcm_from_cvt(hdmi
, dai_map
->cvt
);
483 pcm
->format
= format
;
484 pcm
->channels
= params_channels(hparams
);
489 static int hdac_hdmi_query_port_connlist(struct hdac_ext_device
*hdac
,
490 struct hdac_hdmi_pin
*pin
,
491 struct hdac_hdmi_port
*port
)
493 if (!(get_wcaps(&hdac
->hdac
, pin
->nid
) & AC_WCAP_CONN_LIST
)) {
494 dev_warn(&hdac
->hdac
.dev
,
495 "HDMI: pin %d wcaps %#x does not support connection list\n",
496 pin
->nid
, get_wcaps(&hdac
->hdac
, pin
->nid
));
500 if (hdac_hdmi_port_select_set(hdac
, port
) < 0)
503 port
->num_mux_nids
= snd_hdac_get_connections(&hdac
->hdac
, pin
->nid
,
504 port
->mux_nids
, HDA_MAX_CONNECTIONS
);
505 if (port
->num_mux_nids
== 0)
506 dev_warn(&hdac
->hdac
.dev
,
507 "No connections found for pin:port %d:%d\n",
510 dev_dbg(&hdac
->hdac
.dev
, "num_mux_nids %d for pin:port %d:%d\n",
511 port
->num_mux_nids
, pin
->nid
, port
->id
);
513 return port
->num_mux_nids
;
517 * Query pcm list and return port to which stream is routed.
519 * Also query connection list of the pin, to validate the cvt to port map.
521 * Same stream rendering to multiple ports simultaneously can be done
522 * possibly, but not supported for now in driver. So return the first port
525 static struct hdac_hdmi_port
*hdac_hdmi_get_port_from_cvt(
526 struct hdac_ext_device
*edev
,
527 struct hdac_hdmi_priv
*hdmi
,
528 struct hdac_hdmi_cvt
*cvt
)
530 struct hdac_hdmi_pcm
*pcm
;
531 struct hdac_hdmi_port
*port
= NULL
;
534 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
535 if (pcm
->cvt
== cvt
) {
536 if (list_empty(&pcm
->port_list
))
539 list_for_each_entry(port
, &pcm
->port_list
, head
) {
540 mutex_lock(&pcm
->lock
);
541 ret
= hdac_hdmi_query_port_connlist(edev
,
543 mutex_unlock(&pcm
->lock
);
547 for (i
= 0; i
< port
->num_mux_nids
; i
++) {
548 if (port
->mux_nids
[i
] == cvt
->nid
&&
549 port
->eld
.monitor_present
&&
561 * This tries to get a valid pin and set the HW constraints based on the
562 * ELD. Even if a valid pin is not found return success so that device open
565 static int hdac_hdmi_pcm_open(struct snd_pcm_substream
*substream
,
566 struct snd_soc_dai
*dai
)
568 struct hdac_ext_device
*hdac
= snd_soc_dai_get_drvdata(dai
);
569 struct hdac_hdmi_priv
*hdmi
= hdac
->private_data
;
570 struct hdac_hdmi_dai_port_map
*dai_map
;
571 struct hdac_hdmi_cvt
*cvt
;
572 struct hdac_hdmi_port
*port
;
575 dai_map
= &hdmi
->dai_map
[dai
->id
];
578 port
= hdac_hdmi_get_port_from_cvt(hdac
, hdmi
, cvt
);
581 * To make PA and other userland happy.
582 * userland scans devices so returning error does not help.
586 if ((!port
->eld
.monitor_present
) ||
587 (!port
->eld
.eld_valid
)) {
589 dev_warn(&hdac
->hdac
.dev
,
590 "Failed: present?:%d ELD valid?:%d pin:port: %d:%d\n",
591 port
->eld
.monitor_present
, port
->eld
.eld_valid
,
592 port
->pin
->nid
, port
->id
);
597 dai_map
->port
= port
;
599 ret
= hdac_hdmi_eld_limit_formats(substream
->runtime
,
600 port
->eld
.eld_buffer
);
604 return snd_pcm_hw_constraint_eld(substream
->runtime
,
605 port
->eld
.eld_buffer
);
608 static void hdac_hdmi_pcm_close(struct snd_pcm_substream
*substream
,
609 struct snd_soc_dai
*dai
)
611 struct hdac_ext_device
*hdac
= snd_soc_dai_get_drvdata(dai
);
612 struct hdac_hdmi_priv
*hdmi
= hdac
->private_data
;
613 struct hdac_hdmi_dai_port_map
*dai_map
;
614 struct hdac_hdmi_pcm
*pcm
;
616 dai_map
= &hdmi
->dai_map
[dai
->id
];
618 pcm
= hdac_hdmi_get_pcm_from_cvt(hdmi
, dai_map
->cvt
);
621 mutex_lock(&pcm
->lock
);
622 pcm
->chmap_set
= false;
623 memset(pcm
->chmap
, 0, sizeof(pcm
->chmap
));
625 mutex_unlock(&pcm
->lock
);
629 dai_map
->port
= NULL
;
633 hdac_hdmi_query_cvt_params(struct hdac_device
*hdac
, struct hdac_hdmi_cvt
*cvt
)
636 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
637 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
640 chans
= get_wcaps(hdac
, cvt
->nid
);
641 chans
= get_wcaps_channels(chans
);
643 cvt
->params
.channels_min
= 2;
645 cvt
->params
.channels_max
= chans
;
646 if (chans
> hdmi
->chmap
.channels_max
)
647 hdmi
->chmap
.channels_max
= chans
;
649 err
= snd_hdac_query_supported_pcm(hdac
, cvt
->nid
,
651 &cvt
->params
.formats
,
652 &cvt
->params
.maxbps
);
655 "Failed to query pcm params for nid %d: %d\n",
661 static int hdac_hdmi_fill_widget_info(struct device
*dev
,
662 struct snd_soc_dapm_widget
*w
, enum snd_soc_dapm_type id
,
663 void *priv
, const char *wname
, const char *stream
,
664 struct snd_kcontrol_new
*wc
, int numkc
,
665 int (*event
)(struct snd_soc_dapm_widget
*,
666 struct snd_kcontrol
*, int), unsigned short event_flags
)
669 w
->name
= devm_kstrdup(dev
, wname
, GFP_KERNEL
);
674 w
->reg
= SND_SOC_NOPM
;
676 w
->kcontrol_news
= wc
;
677 w
->num_kcontrols
= numkc
;
680 w
->event_flags
= event_flags
;
685 static void hdac_hdmi_fill_route(struct snd_soc_dapm_route
*route
,
686 const char *sink
, const char *control
, const char *src
,
687 int (*handler
)(struct snd_soc_dapm_widget
*src
,
688 struct snd_soc_dapm_widget
*sink
))
692 route
->control
= control
;
693 route
->connected
= handler
;
696 static struct hdac_hdmi_pcm
*hdac_hdmi_get_pcm(struct hdac_ext_device
*edev
,
697 struct hdac_hdmi_port
*port
)
699 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
700 struct hdac_hdmi_pcm
*pcm
= NULL
;
701 struct hdac_hdmi_port
*p
;
703 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
704 if (list_empty(&pcm
->port_list
))
707 list_for_each_entry(p
, &pcm
->port_list
, head
) {
708 if (p
->id
== port
->id
&& port
->pin
== p
->pin
)
716 static void hdac_hdmi_set_power_state(struct hdac_ext_device
*edev
,
717 hda_nid_t nid
, unsigned int pwr_state
)
719 if (get_wcaps(&edev
->hdac
, nid
) & AC_WCAP_POWER
) {
720 if (!snd_hdac_check_power_state(&edev
->hdac
, nid
, pwr_state
))
721 snd_hdac_codec_write(&edev
->hdac
, nid
, 0,
722 AC_VERB_SET_POWER_STATE
, pwr_state
);
726 static void hdac_hdmi_set_amp(struct hdac_ext_device
*edev
,
727 hda_nid_t nid
, int val
)
729 if (get_wcaps(&edev
->hdac
, nid
) & AC_WCAP_OUT_AMP
)
730 snd_hdac_codec_write(&edev
->hdac
, nid
, 0,
731 AC_VERB_SET_AMP_GAIN_MUTE
, val
);
735 static int hdac_hdmi_pin_output_widget_event(struct snd_soc_dapm_widget
*w
,
736 struct snd_kcontrol
*kc
, int event
)
738 struct hdac_hdmi_port
*port
= w
->priv
;
739 struct hdac_ext_device
*edev
= to_hda_ext_device(w
->dapm
->dev
);
740 struct hdac_hdmi_pcm
*pcm
;
742 dev_dbg(&edev
->hdac
.dev
, "%s: widget: %s event: %x\n",
743 __func__
, w
->name
, event
);
745 pcm
= hdac_hdmi_get_pcm(edev
, port
);
749 /* set the device if pin is mst_capable */
750 if (hdac_hdmi_port_select_set(edev
, port
) < 0)
754 case SND_SOC_DAPM_PRE_PMU
:
755 hdac_hdmi_set_power_state(edev
, port
->pin
->nid
, AC_PWRST_D0
);
757 /* Enable out path for this pin widget */
758 snd_hdac_codec_write(&edev
->hdac
, port
->pin
->nid
, 0,
759 AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
);
761 hdac_hdmi_set_amp(edev
, port
->pin
->nid
, AMP_OUT_UNMUTE
);
763 return hdac_hdmi_setup_audio_infoframe(edev
, pcm
, port
);
765 case SND_SOC_DAPM_POST_PMD
:
766 hdac_hdmi_set_amp(edev
, port
->pin
->nid
, AMP_OUT_MUTE
);
768 /* Disable out path for this pin widget */
769 snd_hdac_codec_write(&edev
->hdac
, port
->pin
->nid
, 0,
770 AC_VERB_SET_PIN_WIDGET_CONTROL
, 0);
772 hdac_hdmi_set_power_state(edev
, port
->pin
->nid
, AC_PWRST_D3
);
780 static int hdac_hdmi_cvt_output_widget_event(struct snd_soc_dapm_widget
*w
,
781 struct snd_kcontrol
*kc
, int event
)
783 struct hdac_hdmi_cvt
*cvt
= w
->priv
;
784 struct hdac_ext_device
*edev
= to_hda_ext_device(w
->dapm
->dev
);
785 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
786 struct hdac_hdmi_pcm
*pcm
;
788 dev_dbg(&edev
->hdac
.dev
, "%s: widget: %s event: %x\n",
789 __func__
, w
->name
, event
);
791 pcm
= hdac_hdmi_get_pcm_from_cvt(hdmi
, cvt
);
796 case SND_SOC_DAPM_PRE_PMU
:
797 hdac_hdmi_set_power_state(edev
, cvt
->nid
, AC_PWRST_D0
);
799 /* Enable transmission */
800 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
801 AC_VERB_SET_DIGI_CONVERT_1
, 1);
803 /* Category Code (CC) to zero */
804 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
805 AC_VERB_SET_DIGI_CONVERT_2
, 0);
807 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
808 AC_VERB_SET_CHANNEL_STREAMID
, pcm
->stream_tag
);
809 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
810 AC_VERB_SET_STREAM_FORMAT
, pcm
->format
);
813 case SND_SOC_DAPM_POST_PMD
:
814 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
815 AC_VERB_SET_CHANNEL_STREAMID
, 0);
816 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
817 AC_VERB_SET_STREAM_FORMAT
, 0);
819 hdac_hdmi_set_power_state(edev
, cvt
->nid
, AC_PWRST_D3
);
827 static int hdac_hdmi_pin_mux_widget_event(struct snd_soc_dapm_widget
*w
,
828 struct snd_kcontrol
*kc
, int event
)
830 struct hdac_hdmi_port
*port
= w
->priv
;
831 struct hdac_ext_device
*edev
= to_hda_ext_device(w
->dapm
->dev
);
834 dev_dbg(&edev
->hdac
.dev
, "%s: widget: %s event: %x\n",
835 __func__
, w
->name
, event
);
838 kc
= w
->kcontrols
[0];
840 mux_idx
= dapm_kcontrol_get_value(kc
);
842 /* set the device if pin is mst_capable */
843 if (hdac_hdmi_port_select_set(edev
, port
) < 0)
847 snd_hdac_codec_write(&edev
->hdac
, port
->pin
->nid
, 0,
848 AC_VERB_SET_CONNECT_SEL
, (mux_idx
- 1));
855 * Based on user selection, map the PINs with the PCMs.
857 static int hdac_hdmi_set_pin_port_mux(struct snd_kcontrol
*kcontrol
,
858 struct snd_ctl_elem_value
*ucontrol
)
861 struct hdac_hdmi_port
*p
, *p_next
;
862 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
863 struct snd_soc_dapm_widget
*w
= snd_soc_dapm_kcontrol_widget(kcontrol
);
864 struct snd_soc_dapm_context
*dapm
= w
->dapm
;
865 struct hdac_hdmi_port
*port
= w
->priv
;
866 struct hdac_ext_device
*edev
= to_hda_ext_device(dapm
->dev
);
867 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
868 struct hdac_hdmi_pcm
*pcm
= NULL
;
869 const char *cvt_name
= e
->texts
[ucontrol
->value
.enumerated
.item
[0]];
871 ret
= snd_soc_dapm_put_enum_double(kcontrol
, ucontrol
);
878 mutex_lock(&hdmi
->pin_mutex
);
879 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
880 if (list_empty(&pcm
->port_list
))
883 list_for_each_entry_safe(p
, p_next
, &pcm
->port_list
, head
) {
884 if (p
== port
&& p
->id
== port
->id
&&
885 p
->pin
== port
->pin
) {
886 hdac_hdmi_jack_report(pcm
, port
, false);
893 * Jack status is not reported during device probe as the
894 * PCMs are not registered by then. So report it here.
896 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
897 if (!strcmp(cvt_name
, pcm
->cvt
->name
)) {
898 list_add_tail(&port
->head
, &pcm
->port_list
);
899 if (port
->eld
.monitor_present
&& port
->eld
.eld_valid
) {
900 hdac_hdmi_jack_report(pcm
, port
, true);
901 mutex_unlock(&hdmi
->pin_mutex
);
906 mutex_unlock(&hdmi
->pin_mutex
);
912 * Ideally the Mux inputs should be based on the num_muxs enumerated, but
913 * the display driver seem to be programming the connection list for the pin
916 * So programming all the possible inputs for the mux, the user has to take
917 * care of selecting the right one and leaving all other inputs selected to
920 static int hdac_hdmi_create_pin_port_muxs(struct hdac_ext_device
*edev
,
921 struct hdac_hdmi_port
*port
,
922 struct snd_soc_dapm_widget
*widget
,
923 const char *widget_name
)
925 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
926 struct hdac_hdmi_pin
*pin
= port
->pin
;
927 struct snd_kcontrol_new
*kc
;
928 struct hdac_hdmi_cvt
*cvt
;
930 char kc_name
[NAME_SIZE
];
931 char mux_items
[NAME_SIZE
];
932 /* To hold inputs to the Pin mux */
933 char *items
[HDA_MAX_CONNECTIONS
];
935 int num_items
= hdmi
->num_cvt
+ 1;
937 kc
= devm_kzalloc(&edev
->hdac
.dev
, sizeof(*kc
), GFP_KERNEL
);
941 se
= devm_kzalloc(&edev
->hdac
.dev
, sizeof(*se
), GFP_KERNEL
);
945 snprintf(kc_name
, NAME_SIZE
, "Pin %d port %d Input",
947 kc
->name
= devm_kstrdup(&edev
->hdac
.dev
, kc_name
, GFP_KERNEL
);
951 kc
->private_value
= (long)se
;
952 kc
->iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
954 kc
->info
= snd_soc_info_enum_double
;
955 kc
->put
= hdac_hdmi_set_pin_port_mux
;
956 kc
->get
= snd_soc_dapm_get_enum_double
;
958 se
->reg
= SND_SOC_NOPM
;
960 /* enum texts: ["NONE", "cvt #", "cvt #", ...] */
961 se
->items
= num_items
;
962 se
->mask
= roundup_pow_of_two(se
->items
) - 1;
964 sprintf(mux_items
, "NONE");
965 items
[i
] = devm_kstrdup(&edev
->hdac
.dev
, mux_items
, GFP_KERNEL
);
969 list_for_each_entry(cvt
, &hdmi
->cvt_list
, head
) {
971 sprintf(mux_items
, "cvt %d", cvt
->nid
);
972 items
[i
] = devm_kstrdup(&edev
->hdac
.dev
, mux_items
, GFP_KERNEL
);
977 se
->texts
= devm_kmemdup(&edev
->hdac
.dev
, items
,
978 (num_items
* sizeof(char *)), GFP_KERNEL
);
982 return hdac_hdmi_fill_widget_info(&edev
->hdac
.dev
, widget
,
983 snd_soc_dapm_mux
, port
, widget_name
, NULL
, kc
, 1,
984 hdac_hdmi_pin_mux_widget_event
,
985 SND_SOC_DAPM_PRE_PMU
| SND_SOC_DAPM_POST_REG
);
988 /* Add cvt <- input <- mux route map */
989 static void hdac_hdmi_add_pinmux_cvt_route(struct hdac_ext_device
*edev
,
990 struct snd_soc_dapm_widget
*widgets
,
991 struct snd_soc_dapm_route
*route
, int rindex
)
993 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
994 const struct snd_kcontrol_new
*kc
;
996 int mux_index
= hdmi
->num_cvt
+ hdmi
->num_ports
;
999 for (i
= 0; i
< hdmi
->num_ports
; i
++) {
1000 kc
= widgets
[mux_index
].kcontrol_news
;
1001 se
= (struct soc_enum
*)kc
->private_value
;
1002 for (j
= 0; j
< hdmi
->num_cvt
; j
++) {
1003 hdac_hdmi_fill_route(&route
[rindex
],
1004 widgets
[mux_index
].name
,
1006 widgets
[j
].name
, NULL
);
1016 * Widgets are added in the below sequence
1017 * Converter widgets for num converters enumerated
1018 * Pin-port widgets for num ports for Pins enumerated
1019 * Pin-port mux widgets to represent connenction list of pin widget
1021 * For each port, one Mux and One output widget is added
1022 * Total widgets elements = num_cvt + (num_ports * 2);
1024 * Routes are added as below:
1025 * pin-port mux -> pin (based on num_ports)
1026 * cvt -> "Input sel control" -> pin-port_mux
1028 * Total route elements:
1029 * num_ports + (pin_muxes * num_cvt)
1031 static int create_fill_widget_route_map(struct snd_soc_dapm_context
*dapm
)
1033 struct snd_soc_dapm_widget
*widgets
;
1034 struct snd_soc_dapm_route
*route
;
1035 struct hdac_ext_device
*edev
= to_hda_ext_device(dapm
->dev
);
1036 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1037 struct snd_soc_dai_driver
*dai_drv
= dapm
->component
->dai_drv
;
1038 char widget_name
[NAME_SIZE
];
1039 struct hdac_hdmi_cvt
*cvt
;
1040 struct hdac_hdmi_pin
*pin
;
1041 int ret
, i
= 0, num_routes
= 0, j
;
1043 if (list_empty(&hdmi
->cvt_list
) || list_empty(&hdmi
->pin_list
))
1046 widgets
= devm_kzalloc(dapm
->dev
, (sizeof(*widgets
) *
1047 ((2 * hdmi
->num_ports
) + hdmi
->num_cvt
)),
1053 /* DAPM widgets to represent each converter widget */
1054 list_for_each_entry(cvt
, &hdmi
->cvt_list
, head
) {
1055 sprintf(widget_name
, "Converter %d", cvt
->nid
);
1056 ret
= hdac_hdmi_fill_widget_info(dapm
->dev
, &widgets
[i
],
1057 snd_soc_dapm_aif_in
, cvt
,
1058 widget_name
, dai_drv
[i
].playback
.stream_name
, NULL
, 0,
1059 hdac_hdmi_cvt_output_widget_event
,
1060 SND_SOC_DAPM_PRE_PMU
| SND_SOC_DAPM_POST_PMD
);
1066 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1067 for (j
= 0; j
< pin
->num_ports
; j
++) {
1068 sprintf(widget_name
, "hif%d-%d Output",
1069 pin
->nid
, pin
->ports
[j
].id
);
1070 ret
= hdac_hdmi_fill_widget_info(dapm
->dev
, &widgets
[i
],
1071 snd_soc_dapm_output
, &pin
->ports
[j
],
1072 widget_name
, NULL
, NULL
, 0,
1073 hdac_hdmi_pin_output_widget_event
,
1074 SND_SOC_DAPM_PRE_PMU
|
1075 SND_SOC_DAPM_POST_PMD
);
1078 pin
->ports
[j
].output_pin
= widgets
[i
].name
;
1083 /* DAPM widgets to represent the connection list to pin widget */
1084 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1085 for (j
= 0; j
< pin
->num_ports
; j
++) {
1086 sprintf(widget_name
, "Pin%d-Port%d Mux",
1087 pin
->nid
, pin
->ports
[j
].id
);
1088 ret
= hdac_hdmi_create_pin_port_muxs(edev
,
1089 &pin
->ports
[j
], &widgets
[i
],
1095 /* For cvt to pin_mux mapping */
1096 num_routes
+= hdmi
->num_cvt
;
1098 /* For pin_mux to pin mapping */
1103 route
= devm_kzalloc(dapm
->dev
, (sizeof(*route
) * num_routes
),
1109 /* Add pin <- NULL <- mux route map */
1110 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1111 for (j
= 0; j
< pin
->num_ports
; j
++) {
1112 int sink_index
= i
+ hdmi
->num_cvt
;
1113 int src_index
= sink_index
+ pin
->num_ports
*
1116 hdac_hdmi_fill_route(&route
[i
],
1117 widgets
[sink_index
].name
, NULL
,
1118 widgets
[src_index
].name
, NULL
);
1123 hdac_hdmi_add_pinmux_cvt_route(edev
, widgets
, route
, i
);
1125 snd_soc_dapm_new_controls(dapm
, widgets
,
1126 ((2 * hdmi
->num_ports
) + hdmi
->num_cvt
));
1128 snd_soc_dapm_add_routes(dapm
, route
, num_routes
);
1129 snd_soc_dapm_new_widgets(dapm
->card
);
1135 static int hdac_hdmi_init_dai_map(struct hdac_ext_device
*edev
)
1137 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1138 struct hdac_hdmi_dai_port_map
*dai_map
;
1139 struct hdac_hdmi_cvt
*cvt
;
1142 if (list_empty(&hdmi
->cvt_list
))
1145 list_for_each_entry(cvt
, &hdmi
->cvt_list
, head
) {
1146 dai_map
= &hdmi
->dai_map
[dai_id
];
1147 dai_map
->dai_id
= dai_id
;
1152 if (dai_id
== HDA_MAX_CVTS
) {
1153 dev_warn(&edev
->hdac
.dev
,
1154 "Max dais supported: %d\n", dai_id
);
1162 static int hdac_hdmi_add_cvt(struct hdac_ext_device
*edev
, hda_nid_t nid
)
1164 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1165 struct hdac_hdmi_cvt
*cvt
;
1166 char name
[NAME_SIZE
];
1168 cvt
= kzalloc(sizeof(*cvt
), GFP_KERNEL
);
1173 sprintf(name
, "cvt %d", cvt
->nid
);
1174 cvt
->name
= kstrdup(name
, GFP_KERNEL
);
1176 list_add_tail(&cvt
->head
, &hdmi
->cvt_list
);
1179 return hdac_hdmi_query_cvt_params(&edev
->hdac
, cvt
);
1182 static int hdac_hdmi_parse_eld(struct hdac_ext_device
*edev
,
1183 struct hdac_hdmi_port
*port
)
1185 unsigned int ver
, mnl
;
1187 ver
= (port
->eld
.eld_buffer
[DRM_ELD_VER
] & DRM_ELD_VER_MASK
)
1188 >> DRM_ELD_VER_SHIFT
;
1190 if (ver
!= ELD_VER_CEA_861D
&& ver
!= ELD_VER_PARTIAL
) {
1191 dev_err(&edev
->hdac
.dev
, "HDMI: Unknown ELD version %d\n", ver
);
1195 mnl
= (port
->eld
.eld_buffer
[DRM_ELD_CEA_EDID_VER_MNL
] &
1196 DRM_ELD_MNL_MASK
) >> DRM_ELD_MNL_SHIFT
;
1198 if (mnl
> ELD_MAX_MNL
) {
1199 dev_err(&edev
->hdac
.dev
, "HDMI: MNL Invalid %d\n", mnl
);
1203 port
->eld
.info
.spk_alloc
= port
->eld
.eld_buffer
[DRM_ELD_SPEAKER
];
1208 static void hdac_hdmi_present_sense(struct hdac_hdmi_pin
*pin
,
1209 struct hdac_hdmi_port
*port
)
1211 struct hdac_ext_device
*edev
= pin
->edev
;
1212 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1213 struct hdac_hdmi_pcm
*pcm
;
1221 * In case of non MST pin, get_eld info API expectes port
1224 mutex_lock(&hdmi
->pin_mutex
);
1225 port
->eld
.monitor_present
= false;
1227 if (pin
->mst_capable
)
1230 size
= snd_hdac_acomp_get_eld(&edev
->hdac
, pin
->nid
, port_id
,
1231 &port
->eld
.monitor_present
,
1232 port
->eld
.eld_buffer
,
1236 size
= min(size
, ELD_MAX_SIZE
);
1237 if (hdac_hdmi_parse_eld(edev
, port
) < 0)
1242 port
->eld
.eld_valid
= true;
1243 port
->eld
.eld_size
= size
;
1245 port
->eld
.eld_valid
= false;
1246 port
->eld
.eld_size
= 0;
1249 pcm
= hdac_hdmi_get_pcm(edev
, port
);
1251 if (!port
->eld
.monitor_present
|| !port
->eld
.eld_valid
) {
1253 dev_err(&edev
->hdac
.dev
, "%s: disconnect for pin:port %d:%d\n",
1254 __func__
, pin
->nid
, port
->id
);
1257 * PCMs are not registered during device probe, so don't
1258 * report jack here. It will be done in usermode mux
1262 hdac_hdmi_jack_report(pcm
, port
, false);
1264 mutex_unlock(&hdmi
->pin_mutex
);
1268 if (port
->eld
.monitor_present
&& port
->eld
.eld_valid
) {
1270 hdac_hdmi_jack_report(pcm
, port
, true);
1272 print_hex_dump_debug("ELD: ", DUMP_PREFIX_OFFSET
, 16, 1,
1273 port
->eld
.eld_buffer
, port
->eld
.eld_size
, false);
1276 mutex_unlock(&hdmi
->pin_mutex
);
1279 static int hdac_hdmi_add_ports(struct hdac_hdmi_priv
*hdmi
,
1280 struct hdac_hdmi_pin
*pin
)
1282 struct hdac_hdmi_port
*ports
;
1283 int max_ports
= HDA_MAX_PORTS
;
1287 * FIXME: max_port may vary for each platform, so pass this as
1288 * as driver data or query from i915 interface when this API is
1292 ports
= kcalloc(max_ports
, sizeof(*ports
), GFP_KERNEL
);
1296 for (i
= 0; i
< max_ports
; i
++) {
1301 pin
->num_ports
= max_ports
;
1305 static int hdac_hdmi_add_pin(struct hdac_ext_device
*edev
, hda_nid_t nid
)
1307 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1308 struct hdac_hdmi_pin
*pin
;
1311 pin
= kzalloc(sizeof(*pin
), GFP_KERNEL
);
1316 pin
->mst_capable
= false;
1318 ret
= hdac_hdmi_add_ports(hdmi
, pin
);
1322 list_add_tail(&pin
->head
, &hdmi
->pin_list
);
1324 hdmi
->num_ports
+= pin
->num_ports
;
1329 #define INTEL_VENDOR_NID 0x08
1330 #define INTEL_GLK_VENDOR_NID 0x0b
1331 #define INTEL_GET_VENDOR_VERB 0xf81
1332 #define INTEL_SET_VENDOR_VERB 0x781
1333 #define INTEL_EN_DP12 0x02 /* enable DP 1.2 features */
1334 #define INTEL_EN_ALL_PIN_CVTS 0x01 /* enable 2nd & 3rd pins and convertors */
1336 static void hdac_hdmi_skl_enable_all_pins(struct hdac_device
*hdac
)
1338 unsigned int vendor_param
;
1339 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
1340 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1341 unsigned int vendor_nid
= hdmi
->drv_data
->vendor_nid
;
1343 vendor_param
= snd_hdac_codec_read(hdac
, vendor_nid
, 0,
1344 INTEL_GET_VENDOR_VERB
, 0);
1345 if (vendor_param
== -1 || vendor_param
& INTEL_EN_ALL_PIN_CVTS
)
1348 vendor_param
|= INTEL_EN_ALL_PIN_CVTS
;
1349 vendor_param
= snd_hdac_codec_read(hdac
, vendor_nid
, 0,
1350 INTEL_SET_VENDOR_VERB
, vendor_param
);
1351 if (vendor_param
== -1)
1355 static void hdac_hdmi_skl_enable_dp12(struct hdac_device
*hdac
)
1357 unsigned int vendor_param
;
1358 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
1359 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1360 unsigned int vendor_nid
= hdmi
->drv_data
->vendor_nid
;
1362 vendor_param
= snd_hdac_codec_read(hdac
, vendor_nid
, 0,
1363 INTEL_GET_VENDOR_VERB
, 0);
1364 if (vendor_param
== -1 || vendor_param
& INTEL_EN_DP12
)
1367 /* enable DP1.2 mode */
1368 vendor_param
|= INTEL_EN_DP12
;
1369 vendor_param
= snd_hdac_codec_read(hdac
, vendor_nid
, 0,
1370 INTEL_SET_VENDOR_VERB
, vendor_param
);
1371 if (vendor_param
== -1)
1376 static const struct snd_soc_dai_ops hdmi_dai_ops
= {
1377 .startup
= hdac_hdmi_pcm_open
,
1378 .shutdown
= hdac_hdmi_pcm_close
,
1379 .hw_params
= hdac_hdmi_set_hw_params
,
1380 .set_tdm_slot
= hdac_hdmi_set_tdm_slot
,
1384 * Each converter can support a stream independently. So a dai is created
1385 * based on the number of converter queried.
1387 static int hdac_hdmi_create_dais(struct hdac_device
*hdac
,
1388 struct snd_soc_dai_driver
**dais
,
1389 struct hdac_hdmi_priv
*hdmi
, int num_dais
)
1391 struct snd_soc_dai_driver
*hdmi_dais
;
1392 struct hdac_hdmi_cvt
*cvt
;
1393 char name
[NAME_SIZE
], dai_name
[NAME_SIZE
];
1396 unsigned int rate_max
= 384000, rate_min
= 8000;
1400 hdmi_dais
= devm_kzalloc(&hdac
->dev
,
1401 (sizeof(*hdmi_dais
) * num_dais
),
1406 list_for_each_entry(cvt
, &hdmi
->cvt_list
, head
) {
1407 ret
= snd_hdac_query_supported_pcm(hdac
, cvt
->nid
,
1408 &rates
, &formats
, &bps
);
1412 sprintf(dai_name
, "intel-hdmi-hifi%d", i
+1);
1413 hdmi_dais
[i
].name
= devm_kstrdup(&hdac
->dev
,
1414 dai_name
, GFP_KERNEL
);
1416 if (!hdmi_dais
[i
].name
)
1419 snprintf(name
, sizeof(name
), "hifi%d", i
+1);
1420 hdmi_dais
[i
].playback
.stream_name
=
1421 devm_kstrdup(&hdac
->dev
, name
, GFP_KERNEL
);
1422 if (!hdmi_dais
[i
].playback
.stream_name
)
1426 * Set caps based on capability queried from the converter.
1427 * It will be constrained runtime based on ELD queried.
1429 hdmi_dais
[i
].playback
.formats
= formats
;
1430 hdmi_dais
[i
].playback
.rates
= rates
;
1431 hdmi_dais
[i
].playback
.rate_max
= rate_max
;
1432 hdmi_dais
[i
].playback
.rate_min
= rate_min
;
1433 hdmi_dais
[i
].playback
.channels_min
= 2;
1434 hdmi_dais
[i
].playback
.channels_max
= 2;
1435 hdmi_dais
[i
].playback
.sig_bits
= bps
;
1436 hdmi_dais
[i
].ops
= &hdmi_dai_ops
;
1446 * Parse all nodes and store the cvt/pin nids in array
1447 * Add one time initialization for pin and cvt widgets
1449 static int hdac_hdmi_parse_and_map_nid(struct hdac_ext_device
*edev
,
1450 struct snd_soc_dai_driver
**dais
, int *num_dais
)
1454 struct hdac_device
*hdac
= &edev
->hdac
;
1455 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1456 struct hdac_hdmi_cvt
*temp_cvt
, *cvt_next
;
1457 struct hdac_hdmi_pin
*temp_pin
, *pin_next
;
1460 hdac_hdmi_skl_enable_all_pins(hdac
);
1461 hdac_hdmi_skl_enable_dp12(hdac
);
1463 num_nodes
= snd_hdac_get_sub_nodes(hdac
, hdac
->afg
, &nid
);
1464 if (!nid
|| num_nodes
<= 0) {
1465 dev_warn(&hdac
->dev
, "HDMI: failed to get afg sub nodes\n");
1469 hdac
->num_nodes
= num_nodes
;
1470 hdac
->start_nid
= nid
;
1472 for (i
= 0; i
< hdac
->num_nodes
; i
++, nid
++) {
1476 caps
= get_wcaps(hdac
, nid
);
1477 type
= get_wcaps_type(caps
);
1479 if (!(caps
& AC_WCAP_DIGITAL
))
1484 case AC_WID_AUD_OUT
:
1485 ret
= hdac_hdmi_add_cvt(edev
, nid
);
1491 ret
= hdac_hdmi_add_pin(edev
, nid
);
1498 hdac
->end_nid
= nid
;
1500 if (!hdmi
->num_pin
|| !hdmi
->num_cvt
) {
1505 ret
= hdac_hdmi_create_dais(hdac
, dais
, hdmi
, hdmi
->num_cvt
);
1507 dev_err(&hdac
->dev
, "Failed to create dais with err: %d\n",
1512 *num_dais
= hdmi
->num_cvt
;
1513 ret
= hdac_hdmi_init_dai_map(edev
);
1520 list_for_each_entry_safe(temp_cvt
, cvt_next
, &hdmi
->cvt_list
, head
) {
1521 list_del(&temp_cvt
->head
);
1522 kfree(temp_cvt
->name
);
1526 list_for_each_entry_safe(temp_pin
, pin_next
, &hdmi
->pin_list
, head
) {
1527 for (i
= 0; i
< temp_pin
->num_ports
; i
++)
1528 temp_pin
->ports
[i
].pin
= NULL
;
1529 kfree(temp_pin
->ports
);
1530 list_del(&temp_pin
->head
);
1537 static void hdac_hdmi_eld_notify_cb(void *aptr
, int port
, int pipe
)
1539 struct hdac_ext_device
*edev
= aptr
;
1540 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1541 struct hdac_hdmi_pin
*pin
= NULL
;
1542 struct hdac_hdmi_port
*hport
= NULL
;
1543 struct snd_soc_codec
*codec
= edev
->scodec
;
1546 /* Don't know how this mapping is derived */
1547 hda_nid_t pin_nid
= port
+ 0x04;
1549 dev_dbg(&edev
->hdac
.dev
, "%s: for pin:%d port=%d\n", __func__
,
1553 * skip notification during system suspend (but not in runtime PM);
1554 * the state will be updated at resume. Also since the ELD and
1555 * connection states are updated in anyway at the end of the resume,
1556 * we can skip it when received during PM process.
1558 if (snd_power_get_state(codec
->component
.card
->snd_card
) !=
1562 if (atomic_read(&edev
->hdac
.in_pm
))
1565 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1566 if (pin
->nid
!= pin_nid
)
1569 /* In case of non MST pin, pipe is -1 */
1571 pin
->mst_capable
= false;
1572 /* if not MST, default is port[0] */
1573 hport
= &pin
->ports
[0];
1575 for (i
= 0; i
< pin
->num_ports
; i
++) {
1576 pin
->mst_capable
= true;
1577 if (pin
->ports
[i
].id
== pipe
) {
1578 hport
= &pin
->ports
[i
];
1585 hdac_hdmi_present_sense(pin
, hport
);
1590 static struct i915_audio_component_audio_ops aops
= {
1591 .pin_eld_notify
= hdac_hdmi_eld_notify_cb
,
1594 static struct snd_pcm
*hdac_hdmi_get_pcm_from_id(struct snd_soc_card
*card
,
1597 struct snd_soc_pcm_runtime
*rtd
;
1599 list_for_each_entry(rtd
, &card
->rtd_list
, list
) {
1600 if (rtd
->pcm
&& (rtd
->pcm
->device
== device
))
1607 /* create jack pin kcontrols */
1608 static int create_fill_jack_kcontrols(struct snd_soc_card
*card
,
1609 struct hdac_ext_device
*edev
)
1611 struct hdac_hdmi_pin
*pin
;
1612 struct snd_kcontrol_new
*kc
;
1613 char kc_name
[NAME_SIZE
], xname
[NAME_SIZE
];
1616 struct snd_soc_codec
*codec
= edev
->scodec
;
1617 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1619 kc
= devm_kcalloc(codec
->dev
, hdmi
->num_ports
,
1620 sizeof(*kc
), GFP_KERNEL
);
1625 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1626 for (j
= 0; j
< pin
->num_ports
; j
++) {
1627 snprintf(xname
, sizeof(xname
), "hif%d-%d Jack",
1628 pin
->nid
, pin
->ports
[j
].id
);
1629 name
= devm_kstrdup(codec
->dev
, xname
, GFP_KERNEL
);
1632 snprintf(kc_name
, sizeof(kc_name
), "%s Switch", xname
);
1633 kc
[i
].name
= devm_kstrdup(codec
->dev
, kc_name
,
1638 kc
[i
].private_value
= (unsigned long)name
;
1639 kc
[i
].iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1641 kc
[i
].info
= snd_soc_dapm_info_pin_switch
;
1642 kc
[i
].put
= snd_soc_dapm_put_pin_switch
;
1643 kc
[i
].get
= snd_soc_dapm_get_pin_switch
;
1648 return snd_soc_add_card_controls(card
, kc
, i
);
1651 int hdac_hdmi_jack_port_init(struct snd_soc_codec
*codec
,
1652 struct snd_soc_dapm_context
*dapm
)
1654 struct hdac_ext_device
*edev
= snd_soc_codec_get_drvdata(codec
);
1655 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1656 struct hdac_hdmi_pin
*pin
;
1657 struct snd_soc_dapm_widget
*widgets
;
1658 struct snd_soc_dapm_route
*route
;
1659 char w_name
[NAME_SIZE
];
1662 widgets
= devm_kcalloc(dapm
->dev
, hdmi
->num_ports
,
1663 sizeof(*widgets
), GFP_KERNEL
);
1668 route
= devm_kcalloc(dapm
->dev
, hdmi
->num_ports
,
1669 sizeof(*route
), GFP_KERNEL
);
1673 /* create Jack DAPM widget */
1674 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1675 for (j
= 0; j
< pin
->num_ports
; j
++) {
1676 snprintf(w_name
, sizeof(w_name
), "hif%d-%d Jack",
1677 pin
->nid
, pin
->ports
[j
].id
);
1679 ret
= hdac_hdmi_fill_widget_info(dapm
->dev
, &widgets
[i
],
1680 snd_soc_dapm_spk
, NULL
,
1681 w_name
, NULL
, NULL
, 0, NULL
, 0);
1685 pin
->ports
[j
].jack_pin
= widgets
[i
].name
;
1686 pin
->ports
[j
].dapm
= dapm
;
1688 /* add to route from Jack widget to output */
1689 hdac_hdmi_fill_route(&route
[i
], pin
->ports
[j
].jack_pin
,
1690 NULL
, pin
->ports
[j
].output_pin
, NULL
);
1696 /* Add Route from Jack widget to the output widget */
1697 ret
= snd_soc_dapm_new_controls(dapm
, widgets
, hdmi
->num_ports
);
1701 ret
= snd_soc_dapm_add_routes(dapm
, route
, hdmi
->num_ports
);
1705 ret
= snd_soc_dapm_new_widgets(dapm
->card
);
1709 /* Add Jack Pin switch Kcontrol */
1710 ret
= create_fill_jack_kcontrols(dapm
->card
, edev
);
1715 /* default set the Jack Pin switch to OFF */
1716 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1717 for (j
= 0; j
< pin
->num_ports
; j
++)
1718 snd_soc_dapm_disable_pin(pin
->ports
[j
].dapm
,
1719 pin
->ports
[j
].jack_pin
);
1724 EXPORT_SYMBOL_GPL(hdac_hdmi_jack_port_init
);
1726 int hdac_hdmi_jack_init(struct snd_soc_dai
*dai
, int device
,
1727 struct snd_soc_jack
*jack
)
1729 struct snd_soc_codec
*codec
= dai
->codec
;
1730 struct hdac_ext_device
*edev
= snd_soc_codec_get_drvdata(codec
);
1731 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1732 struct hdac_hdmi_pcm
*pcm
;
1733 struct snd_pcm
*snd_pcm
;
1737 * this is a new PCM device, create new pcm and
1738 * add to the pcm list
1740 pcm
= kzalloc(sizeof(*pcm
), GFP_KERNEL
);
1743 pcm
->pcm_id
= device
;
1744 pcm
->cvt
= hdmi
->dai_map
[dai
->id
].cvt
;
1745 pcm
->jack_event
= 0;
1747 mutex_init(&pcm
->lock
);
1748 INIT_LIST_HEAD(&pcm
->port_list
);
1749 snd_pcm
= hdac_hdmi_get_pcm_from_id(dai
->component
->card
, device
);
1751 err
= snd_hdac_add_chmap_ctls(snd_pcm
, device
, &hdmi
->chmap
);
1753 dev_err(&edev
->hdac
.dev
,
1754 "chmap control add failed with err: %d for pcm: %d\n",
1761 list_add_tail(&pcm
->head
, &hdmi
->pcm_list
);
1765 EXPORT_SYMBOL_GPL(hdac_hdmi_jack_init
);
1767 static void hdac_hdmi_present_sense_all_pins(struct hdac_ext_device
*edev
,
1768 struct hdac_hdmi_priv
*hdmi
, bool detect_pin_caps
)
1771 struct hdac_hdmi_pin
*pin
;
1773 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1774 if (detect_pin_caps
) {
1776 if (hdac_hdmi_get_port_len(edev
, pin
->nid
) == 0)
1777 pin
->mst_capable
= false;
1779 pin
->mst_capable
= true;
1782 for (i
= 0; i
< pin
->num_ports
; i
++) {
1783 if (!pin
->mst_capable
&& i
> 0)
1786 hdac_hdmi_present_sense(pin
, &pin
->ports
[i
]);
1791 static int hdmi_codec_probe(struct snd_soc_codec
*codec
)
1793 struct hdac_ext_device
*edev
= snd_soc_codec_get_drvdata(codec
);
1794 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1795 struct snd_soc_dapm_context
*dapm
=
1796 snd_soc_component_get_dapm(&codec
->component
);
1797 struct hdac_ext_link
*hlink
= NULL
;
1800 edev
->scodec
= codec
;
1803 * hold the ref while we probe, also no need to drop the ref on
1804 * exit, we call pm_runtime_suspend() so that will do for us
1806 hlink
= snd_hdac_ext_bus_get_link(edev
->ebus
, dev_name(&edev
->hdac
.dev
));
1808 dev_err(&edev
->hdac
.dev
, "hdac link not found\n");
1812 snd_hdac_ext_bus_link_get(edev
->ebus
, hlink
);
1814 ret
= create_fill_widget_route_map(dapm
);
1818 aops
.audio_ptr
= edev
;
1819 ret
= snd_hdac_i915_register_notifier(&aops
);
1821 dev_err(&edev
->hdac
.dev
, "notifier register failed: err: %d\n",
1826 hdac_hdmi_present_sense_all_pins(edev
, hdmi
, true);
1827 /* Imp: Store the card pointer in hda_codec */
1828 edev
->card
= dapm
->card
->snd_card
;
1831 * hdac_device core already sets the state to active and calls
1832 * get_noresume. So enable runtime and set the device to suspend.
1834 pm_runtime_enable(&edev
->hdac
.dev
);
1835 pm_runtime_put(&edev
->hdac
.dev
);
1836 pm_runtime_suspend(&edev
->hdac
.dev
);
1841 static int hdmi_codec_remove(struct snd_soc_codec
*codec
)
1843 struct hdac_ext_device
*edev
= snd_soc_codec_get_drvdata(codec
);
1845 pm_runtime_disable(&edev
->hdac
.dev
);
1850 static int hdmi_codec_prepare(struct device
*dev
)
1852 struct hdac_ext_device
*edev
= to_hda_ext_device(dev
);
1853 struct hdac_device
*hdac
= &edev
->hdac
;
1855 pm_runtime_get_sync(&edev
->hdac
.dev
);
1859 * codec_read is preferred over codec_write to set the power state.
1860 * This way verb is send to set the power state and response
1861 * is received. So setting power state is ensured without using loop
1862 * to read the state.
1864 snd_hdac_codec_read(hdac
, hdac
->afg
, 0, AC_VERB_SET_POWER_STATE
,
1870 static void hdmi_codec_complete(struct device
*dev
)
1872 struct hdac_ext_device
*edev
= to_hda_ext_device(dev
);
1873 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1874 struct hdac_device
*hdac
= &edev
->hdac
;
1877 snd_hdac_codec_read(hdac
, hdac
->afg
, 0, AC_VERB_SET_POWER_STATE
,
1880 hdac_hdmi_skl_enable_all_pins(&edev
->hdac
);
1881 hdac_hdmi_skl_enable_dp12(&edev
->hdac
);
1884 * As the ELD notify callback request is not entertained while the
1885 * device is in suspend state. Need to manually check detection of
1886 * all pins here. pin capablity change is not support, so use the
1887 * already set pin caps.
1889 hdac_hdmi_present_sense_all_pins(edev
, hdmi
, false);
1891 pm_runtime_put_sync(&edev
->hdac
.dev
);
1894 #define hdmi_codec_prepare NULL
1895 #define hdmi_codec_complete NULL
1898 static const struct snd_soc_codec_driver hdmi_hda_codec
= {
1899 .probe
= hdmi_codec_probe
,
1900 .remove
= hdmi_codec_remove
,
1901 .idle_bias_off
= true,
1904 static void hdac_hdmi_get_chmap(struct hdac_device
*hdac
, int pcm_idx
,
1905 unsigned char *chmap
)
1907 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
1908 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1909 struct hdac_hdmi_pcm
*pcm
= get_hdmi_pcm_from_id(hdmi
, pcm_idx
);
1911 memcpy(chmap
, pcm
->chmap
, ARRAY_SIZE(pcm
->chmap
));
1914 static void hdac_hdmi_set_chmap(struct hdac_device
*hdac
, int pcm_idx
,
1915 unsigned char *chmap
, int prepared
)
1917 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
1918 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1919 struct hdac_hdmi_pcm
*pcm
= get_hdmi_pcm_from_id(hdmi
, pcm_idx
);
1920 struct hdac_hdmi_port
*port
;
1925 if (list_empty(&pcm
->port_list
))
1928 mutex_lock(&pcm
->lock
);
1929 pcm
->chmap_set
= true;
1930 memcpy(pcm
->chmap
, chmap
, ARRAY_SIZE(pcm
->chmap
));
1931 list_for_each_entry(port
, &pcm
->port_list
, head
)
1933 hdac_hdmi_setup_audio_infoframe(edev
, pcm
, port
);
1934 mutex_unlock(&pcm
->lock
);
1937 static bool is_hdac_hdmi_pcm_attached(struct hdac_device
*hdac
, int pcm_idx
)
1939 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
1940 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1941 struct hdac_hdmi_pcm
*pcm
= get_hdmi_pcm_from_id(hdmi
, pcm_idx
);
1946 if (list_empty(&pcm
->port_list
))
1952 static int hdac_hdmi_get_spk_alloc(struct hdac_device
*hdac
, int pcm_idx
)
1954 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
1955 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1956 struct hdac_hdmi_pcm
*pcm
= get_hdmi_pcm_from_id(hdmi
, pcm_idx
);
1957 struct hdac_hdmi_port
*port
;
1962 if (list_empty(&pcm
->port_list
))
1965 port
= list_first_entry(&pcm
->port_list
, struct hdac_hdmi_port
, head
);
1970 if (!port
|| !port
->eld
.eld_valid
)
1973 return port
->eld
.info
.spk_alloc
;
1976 static struct hdac_hdmi_drv_data intel_glk_drv_data
= {
1977 .vendor_nid
= INTEL_GLK_VENDOR_NID
,
1980 static struct hdac_hdmi_drv_data intel_drv_data
= {
1981 .vendor_nid
= INTEL_VENDOR_NID
,
1984 static int hdac_hdmi_dev_probe(struct hdac_ext_device
*edev
)
1986 struct hdac_device
*codec
= &edev
->hdac
;
1987 struct hdac_hdmi_priv
*hdmi_priv
;
1988 struct snd_soc_dai_driver
*hdmi_dais
= NULL
;
1989 struct hdac_ext_link
*hlink
= NULL
;
1992 struct hdac_driver
*hdrv
= drv_to_hdac_driver(codec
->dev
.driver
);
1993 const struct hda_device_id
*hdac_id
= hdac_get_device_id(codec
, hdrv
);
1995 /* hold the ref while we probe */
1996 hlink
= snd_hdac_ext_bus_get_link(edev
->ebus
, dev_name(&edev
->hdac
.dev
));
1998 dev_err(&edev
->hdac
.dev
, "hdac link not found\n");
2002 snd_hdac_ext_bus_link_get(edev
->ebus
, hlink
);
2004 hdmi_priv
= devm_kzalloc(&codec
->dev
, sizeof(*hdmi_priv
), GFP_KERNEL
);
2005 if (hdmi_priv
== NULL
)
2008 edev
->private_data
= hdmi_priv
;
2009 snd_hdac_register_chmap_ops(codec
, &hdmi_priv
->chmap
);
2010 hdmi_priv
->chmap
.ops
.get_chmap
= hdac_hdmi_get_chmap
;
2011 hdmi_priv
->chmap
.ops
.set_chmap
= hdac_hdmi_set_chmap
;
2012 hdmi_priv
->chmap
.ops
.is_pcm_attached
= is_hdac_hdmi_pcm_attached
;
2013 hdmi_priv
->chmap
.ops
.get_spk_alloc
= hdac_hdmi_get_spk_alloc
;
2018 if (hdac_id
->driver_data
)
2019 hdmi_priv
->drv_data
=
2020 (struct hdac_hdmi_drv_data
*)hdac_id
->driver_data
;
2022 hdmi_priv
->drv_data
= &intel_drv_data
;
2024 dev_set_drvdata(&codec
->dev
, edev
);
2026 INIT_LIST_HEAD(&hdmi_priv
->pin_list
);
2027 INIT_LIST_HEAD(&hdmi_priv
->cvt_list
);
2028 INIT_LIST_HEAD(&hdmi_priv
->pcm_list
);
2029 mutex_init(&hdmi_priv
->pin_mutex
);
2032 * Turned off in the runtime_suspend during the first explicit
2033 * pm_runtime_suspend call.
2035 ret
= snd_hdac_display_power(edev
->hdac
.bus
, true);
2037 dev_err(&edev
->hdac
.dev
,
2038 "Cannot turn on display power on i915 err: %d\n",
2043 ret
= hdac_hdmi_parse_and_map_nid(edev
, &hdmi_dais
, &num_dais
);
2045 dev_err(&codec
->dev
,
2046 "Failed in parse and map nid with err: %d\n", ret
);
2050 /* ASoC specific initialization */
2051 ret
= snd_soc_register_codec(&codec
->dev
, &hdmi_hda_codec
,
2052 hdmi_dais
, num_dais
);
2054 snd_hdac_ext_bus_link_put(edev
->ebus
, hlink
);
2059 static int hdac_hdmi_dev_remove(struct hdac_ext_device
*edev
)
2061 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
2062 struct hdac_hdmi_pin
*pin
, *pin_next
;
2063 struct hdac_hdmi_cvt
*cvt
, *cvt_next
;
2064 struct hdac_hdmi_pcm
*pcm
, *pcm_next
;
2065 struct hdac_hdmi_port
*port
, *port_next
;
2068 snd_soc_unregister_codec(&edev
->hdac
.dev
);
2070 list_for_each_entry_safe(pcm
, pcm_next
, &hdmi
->pcm_list
, head
) {
2072 if (list_empty(&pcm
->port_list
))
2075 list_for_each_entry_safe(port
, port_next
,
2076 &pcm
->port_list
, head
)
2077 list_del(&port
->head
);
2079 list_del(&pcm
->head
);
2083 list_for_each_entry_safe(cvt
, cvt_next
, &hdmi
->cvt_list
, head
) {
2084 list_del(&cvt
->head
);
2089 list_for_each_entry_safe(pin
, pin_next
, &hdmi
->pin_list
, head
) {
2090 for (i
= 0; i
< pin
->num_ports
; i
++)
2091 pin
->ports
[i
].pin
= NULL
;
2093 list_del(&pin
->head
);
2101 static int hdac_hdmi_runtime_suspend(struct device
*dev
)
2103 struct hdac_ext_device
*edev
= to_hda_ext_device(dev
);
2104 struct hdac_device
*hdac
= &edev
->hdac
;
2105 struct hdac_bus
*bus
= hdac
->bus
;
2106 struct hdac_ext_bus
*ebus
= hbus_to_ebus(bus
);
2107 struct hdac_ext_link
*hlink
= NULL
;
2110 dev_dbg(dev
, "Enter: %s\n", __func__
);
2112 /* controller may not have been initialized for the first time */
2118 * codec_read is preferred over codec_write to set the power state.
2119 * This way verb is send to set the power state and response
2120 * is received. So setting power state is ensured without using loop
2121 * to read the state.
2123 snd_hdac_codec_read(hdac
, hdac
->afg
, 0, AC_VERB_SET_POWER_STATE
,
2125 err
= snd_hdac_display_power(bus
, false);
2127 dev_err(bus
->dev
, "Cannot turn on display power on i915\n");
2131 hlink
= snd_hdac_ext_bus_get_link(ebus
, dev_name(dev
));
2133 dev_err(dev
, "hdac link not found\n");
2137 snd_hdac_ext_bus_link_put(ebus
, hlink
);
2142 static int hdac_hdmi_runtime_resume(struct device
*dev
)
2144 struct hdac_ext_device
*edev
= to_hda_ext_device(dev
);
2145 struct hdac_device
*hdac
= &edev
->hdac
;
2146 struct hdac_bus
*bus
= hdac
->bus
;
2147 struct hdac_ext_bus
*ebus
= hbus_to_ebus(bus
);
2148 struct hdac_ext_link
*hlink
= NULL
;
2151 dev_dbg(dev
, "Enter: %s\n", __func__
);
2153 /* controller may not have been initialized for the first time */
2157 hlink
= snd_hdac_ext_bus_get_link(ebus
, dev_name(dev
));
2159 dev_err(dev
, "hdac link not found\n");
2163 snd_hdac_ext_bus_link_get(ebus
, hlink
);
2165 err
= snd_hdac_display_power(bus
, true);
2167 dev_err(bus
->dev
, "Cannot turn on display power on i915\n");
2171 hdac_hdmi_skl_enable_all_pins(&edev
->hdac
);
2172 hdac_hdmi_skl_enable_dp12(&edev
->hdac
);
2175 snd_hdac_codec_read(hdac
, hdac
->afg
, 0, AC_VERB_SET_POWER_STATE
,
2181 #define hdac_hdmi_runtime_suspend NULL
2182 #define hdac_hdmi_runtime_resume NULL
2185 static const struct dev_pm_ops hdac_hdmi_pm
= {
2186 SET_RUNTIME_PM_OPS(hdac_hdmi_runtime_suspend
, hdac_hdmi_runtime_resume
, NULL
)
2187 .prepare
= hdmi_codec_prepare
,
2188 .complete
= hdmi_codec_complete
,
2191 static const struct hda_device_id hdmi_list
[] = {
2192 HDA_CODEC_EXT_ENTRY(0x80862809, 0x100000, "Skylake HDMI", 0),
2193 HDA_CODEC_EXT_ENTRY(0x8086280a, 0x100000, "Broxton HDMI", 0),
2194 HDA_CODEC_EXT_ENTRY(0x8086280b, 0x100000, "Kabylake HDMI", 0),
2195 HDA_CODEC_EXT_ENTRY(0x8086280d, 0x100000, "Geminilake HDMI",
2196 &intel_glk_drv_data
),
2200 MODULE_DEVICE_TABLE(hdaudio
, hdmi_list
);
2202 static struct hdac_ext_driver hdmi_driver
= {
2205 .name
= "HDMI HDA Codec",
2206 .pm
= &hdac_hdmi_pm
,
2208 .id_table
= hdmi_list
,
2210 .probe
= hdac_hdmi_dev_probe
,
2211 .remove
= hdac_hdmi_dev_remove
,
2214 static int __init
hdmi_init(void)
2216 return snd_hda_ext_driver_register(&hdmi_driver
);
2219 static void __exit
hdmi_exit(void)
2221 snd_hda_ext_driver_unregister(&hdmi_driver
);
2224 module_init(hdmi_init
);
2225 module_exit(hdmi_exit
);
2227 MODULE_LICENSE("GPL v2");
2228 MODULE_DESCRIPTION("HDMI HD codec");
2229 MODULE_AUTHOR("Samreen Nilofer<samreen.nilofer@intel.com>");
2230 MODULE_AUTHOR("Subhransu S. Prusty<subhransu.s.prusty@intel.com>");