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_priv
{
125 struct hdac_hdmi_dai_port_map dai_map
[HDA_MAX_CVTS
];
126 struct list_head pin_list
;
127 struct list_head cvt_list
;
128 struct list_head pcm_list
;
132 struct mutex pin_mutex
;
133 struct hdac_chmap chmap
;
136 static struct hdac_hdmi_pcm
*
137 hdac_hdmi_get_pcm_from_cvt(struct hdac_hdmi_priv
*hdmi
,
138 struct hdac_hdmi_cvt
*cvt
)
140 struct hdac_hdmi_pcm
*pcm
= NULL
;
142 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
150 static void hdac_hdmi_jack_report(struct hdac_hdmi_pcm
*pcm
,
151 struct hdac_hdmi_port
*port
, bool is_connect
)
153 struct hdac_ext_device
*edev
= port
->pin
->edev
;
156 snd_soc_dapm_enable_pin(port
->dapm
, port
->jack_pin
);
158 snd_soc_dapm_disable_pin(port
->dapm
, port
->jack_pin
);
162 * Report Jack connect event when a device is connected
163 * for the first time where same PCM is attached to multiple
166 if (pcm
->jack_event
== 0) {
167 dev_dbg(&edev
->hdac
.dev
,
168 "jack report for pcm=%d\n",
170 snd_soc_jack_report(pcm
->jack
, SND_JACK_AVOUT
,
176 * Report Jack disconnect event when a device is disconnected
177 * is the only last connected device when same PCM is attached
180 if (pcm
->jack_event
== 1)
181 snd_soc_jack_report(pcm
->jack
, 0, SND_JACK_AVOUT
);
182 if (pcm
->jack_event
> 0)
186 snd_soc_dapm_sync(port
->dapm
);
189 /* MST supported verbs */
191 * Get the no devices that can be connected to a port on the Pin widget.
193 static int hdac_hdmi_get_port_len(struct hdac_ext_device
*hdac
, hda_nid_t nid
)
196 unsigned int type
, param
;
198 caps
= get_wcaps(&hdac
->hdac
, nid
);
199 type
= get_wcaps_type(caps
);
201 if (!(caps
& AC_WCAP_DIGITAL
) || (type
!= AC_WID_PIN
))
204 param
= snd_hdac_read_parm_uncached(&hdac
->hdac
, nid
,
209 return param
& AC_DEV_LIST_LEN_MASK
;
213 * Get the port entry select on the pin. Return the port entry
214 * id selected on the pin. Return 0 means the first port entry
215 * is selected or MST is not supported.
217 static int hdac_hdmi_port_select_get(struct hdac_ext_device
*hdac
,
218 struct hdac_hdmi_port
*port
)
220 return snd_hdac_codec_read(&hdac
->hdac
, port
->pin
->nid
,
221 0, AC_VERB_GET_DEVICE_SEL
, 0);
225 * Sets the selected port entry for the configuring Pin widget verb.
226 * returns error if port set is not equal to port get otherwise success
228 static int hdac_hdmi_port_select_set(struct hdac_ext_device
*hdac
,
229 struct hdac_hdmi_port
*port
)
233 if (!port
->pin
->mst_capable
)
236 /* AC_PAR_DEVLIST_LEN is 0 based. */
237 num_ports
= hdac_hdmi_get_port_len(hdac
, port
->pin
->nid
);
242 * Device List Length is a 0 based integer value indicating the
243 * number of sink device that a MST Pin Widget can support.
245 if (num_ports
+ 1 < port
->id
)
248 snd_hdac_codec_write(&hdac
->hdac
, port
->pin
->nid
, 0,
249 AC_VERB_SET_DEVICE_SEL
, port
->id
);
251 if (port
->id
!= hdac_hdmi_port_select_get(hdac
, port
))
254 dev_dbg(&hdac
->hdac
.dev
, "Selected the port=%d\n", port
->id
);
259 static struct hdac_hdmi_pcm
*get_hdmi_pcm_from_id(struct hdac_hdmi_priv
*hdmi
,
262 struct hdac_hdmi_pcm
*pcm
;
264 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
265 if (pcm
->pcm_id
== pcm_idx
)
272 static inline struct hdac_ext_device
*to_hda_ext_device(struct device
*dev
)
274 struct hdac_device
*hdac
= dev_to_hdac_dev(dev
);
276 return to_ehdac_device(hdac
);
279 static unsigned int sad_format(const u8
*sad
)
281 return ((sad
[0] >> 0x3) & 0x1f);
284 static unsigned int sad_sample_bits_lpcm(const u8
*sad
)
289 static int hdac_hdmi_eld_limit_formats(struct snd_pcm_runtime
*runtime
,
292 u64 formats
= SNDRV_PCM_FMTBIT_S16
;
294 const u8
*sad
, *eld_buf
= eld
;
296 sad
= drm_eld_sad(eld_buf
);
298 goto format_constraint
;
300 for (i
= drm_eld_sad_count(eld_buf
); i
> 0; i
--, sad
+= 3) {
301 if (sad_format(sad
) == 1) { /* AUDIO_CODING_TYPE_LPCM */
304 * the controller support 20 and 24 bits in 32 bit
305 * container so we set S32
307 if (sad_sample_bits_lpcm(sad
) & 0x6)
308 formats
|= SNDRV_PCM_FMTBIT_S32
;
313 return snd_pcm_hw_constraint_mask64(runtime
, SNDRV_PCM_HW_PARAM_FORMAT
,
319 hdac_hdmi_set_dip_index(struct hdac_ext_device
*hdac
, hda_nid_t pin_nid
,
320 int packet_index
, int byte_index
)
324 val
= (packet_index
<< 5) | (byte_index
& 0x1f);
326 snd_hdac_codec_write(&hdac
->hdac
, pin_nid
, 0,
327 AC_VERB_SET_HDMI_DIP_INDEX
, val
);
330 struct dp_audio_infoframe
{
333 u8 ver
; /* 0x11 << 2 */
335 u8 CC02_CT47
; /* match with HDMI infoframe from this on */
339 u8 LFEPBL01_LSV36_DM_INH7
;
342 static int hdac_hdmi_setup_audio_infoframe(struct hdac_ext_device
*hdac
,
343 struct hdac_hdmi_pcm
*pcm
, struct hdac_hdmi_port
*port
)
345 uint8_t buffer
[HDMI_INFOFRAME_HEADER_SIZE
+ HDMI_AUDIO_INFOFRAME_SIZE
];
346 struct hdmi_audio_infoframe frame
;
347 struct hdac_hdmi_pin
*pin
= port
->pin
;
348 struct dp_audio_infoframe dp_ai
;
349 struct hdac_hdmi_priv
*hdmi
= hdac
->private_data
;
350 struct hdac_hdmi_cvt
*cvt
= pcm
->cvt
;
358 ca
= snd_hdac_channel_allocation(&hdac
->hdac
, port
->eld
.info
.spk_alloc
,
359 pcm
->channels
, pcm
->chmap_set
, true, pcm
->chmap
);
361 channels
= snd_hdac_get_active_channels(ca
);
362 hdmi
->chmap
.ops
.set_channel_count(&hdac
->hdac
, cvt
->nid
, channels
);
364 snd_hdac_setup_channel_mapping(&hdmi
->chmap
, pin
->nid
, false, ca
,
365 pcm
->channels
, pcm
->chmap
, pcm
->chmap_set
);
367 eld_buf
= port
->eld
.eld_buffer
;
368 conn_type
= drm_eld_get_conn_type(eld_buf
);
371 case DRM_ELD_CONN_TYPE_HDMI
:
372 hdmi_audio_infoframe_init(&frame
);
374 frame
.channels
= channels
;
375 frame
.channel_allocation
= ca
;
377 ret
= hdmi_audio_infoframe_pack(&frame
, buffer
, sizeof(buffer
));
383 case DRM_ELD_CONN_TYPE_DP
:
384 memset(&dp_ai
, 0, sizeof(dp_ai
));
387 dp_ai
.ver
= 0x11 << 2;
388 dp_ai
.CC02_CT47
= channels
- 1;
395 dev_err(&hdac
->hdac
.dev
, "Invalid connection type: %d\n",
400 /* stop infoframe transmission */
401 hdac_hdmi_set_dip_index(hdac
, pin
->nid
, 0x0, 0x0);
402 snd_hdac_codec_write(&hdac
->hdac
, pin
->nid
, 0,
403 AC_VERB_SET_HDMI_DIP_XMIT
, AC_DIPXMIT_DISABLE
);
406 /* Fill infoframe. Index auto-incremented */
407 hdac_hdmi_set_dip_index(hdac
, pin
->nid
, 0x0, 0x0);
408 if (conn_type
== DRM_ELD_CONN_TYPE_HDMI
) {
409 for (i
= 0; i
< sizeof(buffer
); i
++)
410 snd_hdac_codec_write(&hdac
->hdac
, pin
->nid
, 0,
411 AC_VERB_SET_HDMI_DIP_DATA
, buffer
[i
]);
413 for (i
= 0; i
< sizeof(dp_ai
); i
++)
414 snd_hdac_codec_write(&hdac
->hdac
, pin
->nid
, 0,
415 AC_VERB_SET_HDMI_DIP_DATA
, dip
[i
]);
418 /* Start infoframe */
419 hdac_hdmi_set_dip_index(hdac
, pin
->nid
, 0x0, 0x0);
420 snd_hdac_codec_write(&hdac
->hdac
, pin
->nid
, 0,
421 AC_VERB_SET_HDMI_DIP_XMIT
, AC_DIPXMIT_BEST
);
426 static int hdac_hdmi_set_tdm_slot(struct snd_soc_dai
*dai
,
427 unsigned int tx_mask
, unsigned int rx_mask
,
428 int slots
, int slot_width
)
430 struct hdac_ext_device
*edev
= snd_soc_dai_get_drvdata(dai
);
431 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
432 struct hdac_hdmi_dai_port_map
*dai_map
;
433 struct hdac_hdmi_pcm
*pcm
;
435 dev_dbg(&edev
->hdac
.dev
, "%s: strm_tag: %d\n", __func__
, tx_mask
);
437 dai_map
= &hdmi
->dai_map
[dai
->id
];
439 pcm
= hdac_hdmi_get_pcm_from_cvt(hdmi
, dai_map
->cvt
);
442 pcm
->stream_tag
= (tx_mask
<< 4);
447 static int hdac_hdmi_set_hw_params(struct snd_pcm_substream
*substream
,
448 struct snd_pcm_hw_params
*hparams
, struct snd_soc_dai
*dai
)
450 struct hdac_ext_device
*hdac
= snd_soc_dai_get_drvdata(dai
);
451 struct hdac_hdmi_priv
*hdmi
= hdac
->private_data
;
452 struct hdac_hdmi_dai_port_map
*dai_map
;
453 struct hdac_hdmi_port
*port
;
454 struct hdac_hdmi_pcm
*pcm
;
457 dai_map
= &hdmi
->dai_map
[dai
->id
];
458 port
= dai_map
->port
;
463 if ((!port
->eld
.monitor_present
) || (!port
->eld
.eld_valid
)) {
464 dev_err(&hdac
->hdac
.dev
,
465 "device is not configured for this pin:port%d:%d\n",
466 port
->pin
->nid
, port
->id
);
470 format
= snd_hdac_calc_stream_format(params_rate(hparams
),
471 params_channels(hparams
), params_format(hparams
),
474 pcm
= hdac_hdmi_get_pcm_from_cvt(hdmi
, dai_map
->cvt
);
478 pcm
->format
= format
;
479 pcm
->channels
= params_channels(hparams
);
484 static int hdac_hdmi_query_port_connlist(struct hdac_ext_device
*hdac
,
485 struct hdac_hdmi_pin
*pin
,
486 struct hdac_hdmi_port
*port
)
488 if (!(get_wcaps(&hdac
->hdac
, pin
->nid
) & AC_WCAP_CONN_LIST
)) {
489 dev_warn(&hdac
->hdac
.dev
,
490 "HDMI: pin %d wcaps %#x does not support connection list\n",
491 pin
->nid
, get_wcaps(&hdac
->hdac
, pin
->nid
));
495 if (hdac_hdmi_port_select_set(hdac
, port
) < 0)
498 port
->num_mux_nids
= snd_hdac_get_connections(&hdac
->hdac
, pin
->nid
,
499 port
->mux_nids
, HDA_MAX_CONNECTIONS
);
500 if (port
->num_mux_nids
== 0)
501 dev_warn(&hdac
->hdac
.dev
,
502 "No connections found for pin:port %d:%d\n",
505 dev_dbg(&hdac
->hdac
.dev
, "num_mux_nids %d for pin:port %d:%d\n",
506 port
->num_mux_nids
, pin
->nid
, port
->id
);
508 return port
->num_mux_nids
;
512 * Query pcm list and return port to which stream is routed.
514 * Also query connection list of the pin, to validate the cvt to port map.
516 * Same stream rendering to multiple ports simultaneously can be done
517 * possibly, but not supported for now in driver. So return the first port
520 static struct hdac_hdmi_port
*hdac_hdmi_get_port_from_cvt(
521 struct hdac_ext_device
*edev
,
522 struct hdac_hdmi_priv
*hdmi
,
523 struct hdac_hdmi_cvt
*cvt
)
525 struct hdac_hdmi_pcm
*pcm
;
526 struct hdac_hdmi_port
*port
= NULL
;
529 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
530 if (pcm
->cvt
== cvt
) {
531 if (list_empty(&pcm
->port_list
))
534 list_for_each_entry(port
, &pcm
->port_list
, head
) {
535 mutex_lock(&pcm
->lock
);
536 ret
= hdac_hdmi_query_port_connlist(edev
,
538 mutex_unlock(&pcm
->lock
);
542 for (i
= 0; i
< port
->num_mux_nids
; i
++) {
543 if (port
->mux_nids
[i
] == cvt
->nid
&&
544 port
->eld
.monitor_present
&&
556 * This tries to get a valid pin and set the HW constraints based on the
557 * ELD. Even if a valid pin is not found return success so that device open
560 static int hdac_hdmi_pcm_open(struct snd_pcm_substream
*substream
,
561 struct snd_soc_dai
*dai
)
563 struct hdac_ext_device
*hdac
= snd_soc_dai_get_drvdata(dai
);
564 struct hdac_hdmi_priv
*hdmi
= hdac
->private_data
;
565 struct hdac_hdmi_dai_port_map
*dai_map
;
566 struct hdac_hdmi_cvt
*cvt
;
567 struct hdac_hdmi_port
*port
;
570 dai_map
= &hdmi
->dai_map
[dai
->id
];
573 port
= hdac_hdmi_get_port_from_cvt(hdac
, hdmi
, cvt
);
576 * To make PA and other userland happy.
577 * userland scans devices so returning error does not help.
581 if ((!port
->eld
.monitor_present
) ||
582 (!port
->eld
.eld_valid
)) {
584 dev_warn(&hdac
->hdac
.dev
,
585 "Failed: present?:%d ELD valid?:%d pin:port: %d:%d\n",
586 port
->eld
.monitor_present
, port
->eld
.eld_valid
,
587 port
->pin
->nid
, port
->id
);
592 dai_map
->port
= port
;
594 ret
= hdac_hdmi_eld_limit_formats(substream
->runtime
,
595 port
->eld
.eld_buffer
);
599 return snd_pcm_hw_constraint_eld(substream
->runtime
,
600 port
->eld
.eld_buffer
);
603 static void hdac_hdmi_pcm_close(struct snd_pcm_substream
*substream
,
604 struct snd_soc_dai
*dai
)
606 struct hdac_ext_device
*hdac
= snd_soc_dai_get_drvdata(dai
);
607 struct hdac_hdmi_priv
*hdmi
= hdac
->private_data
;
608 struct hdac_hdmi_dai_port_map
*dai_map
;
609 struct hdac_hdmi_pcm
*pcm
;
611 dai_map
= &hdmi
->dai_map
[dai
->id
];
613 pcm
= hdac_hdmi_get_pcm_from_cvt(hdmi
, dai_map
->cvt
);
616 mutex_lock(&pcm
->lock
);
617 pcm
->chmap_set
= false;
618 memset(pcm
->chmap
, 0, sizeof(pcm
->chmap
));
620 mutex_unlock(&pcm
->lock
);
624 dai_map
->port
= NULL
;
628 hdac_hdmi_query_cvt_params(struct hdac_device
*hdac
, struct hdac_hdmi_cvt
*cvt
)
631 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
632 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
635 chans
= get_wcaps(hdac
, cvt
->nid
);
636 chans
= get_wcaps_channels(chans
);
638 cvt
->params
.channels_min
= 2;
640 cvt
->params
.channels_max
= chans
;
641 if (chans
> hdmi
->chmap
.channels_max
)
642 hdmi
->chmap
.channels_max
= chans
;
644 err
= snd_hdac_query_supported_pcm(hdac
, cvt
->nid
,
646 &cvt
->params
.formats
,
647 &cvt
->params
.maxbps
);
650 "Failed to query pcm params for nid %d: %d\n",
656 static int hdac_hdmi_fill_widget_info(struct device
*dev
,
657 struct snd_soc_dapm_widget
*w
, enum snd_soc_dapm_type id
,
658 void *priv
, const char *wname
, const char *stream
,
659 struct snd_kcontrol_new
*wc
, int numkc
,
660 int (*event
)(struct snd_soc_dapm_widget
*,
661 struct snd_kcontrol
*, int), unsigned short event_flags
)
664 w
->name
= devm_kstrdup(dev
, wname
, GFP_KERNEL
);
669 w
->reg
= SND_SOC_NOPM
;
671 w
->kcontrol_news
= wc
;
672 w
->num_kcontrols
= numkc
;
675 w
->event_flags
= event_flags
;
680 static void hdac_hdmi_fill_route(struct snd_soc_dapm_route
*route
,
681 const char *sink
, const char *control
, const char *src
,
682 int (*handler
)(struct snd_soc_dapm_widget
*src
,
683 struct snd_soc_dapm_widget
*sink
))
687 route
->control
= control
;
688 route
->connected
= handler
;
691 static struct hdac_hdmi_pcm
*hdac_hdmi_get_pcm(struct hdac_ext_device
*edev
,
692 struct hdac_hdmi_port
*port
)
694 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
695 struct hdac_hdmi_pcm
*pcm
= NULL
;
696 struct hdac_hdmi_port
*p
;
698 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
699 if (list_empty(&pcm
->port_list
))
702 list_for_each_entry(p
, &pcm
->port_list
, head
) {
703 if (p
->id
== port
->id
&& port
->pin
== p
->pin
)
711 static void hdac_hdmi_set_power_state(struct hdac_ext_device
*edev
,
712 hda_nid_t nid
, unsigned int pwr_state
)
714 if (get_wcaps(&edev
->hdac
, nid
) & AC_WCAP_POWER
) {
715 if (!snd_hdac_check_power_state(&edev
->hdac
, nid
, pwr_state
))
716 snd_hdac_codec_write(&edev
->hdac
, nid
, 0,
717 AC_VERB_SET_POWER_STATE
, pwr_state
);
721 static void hdac_hdmi_set_amp(struct hdac_ext_device
*edev
,
722 hda_nid_t nid
, int val
)
724 if (get_wcaps(&edev
->hdac
, nid
) & AC_WCAP_OUT_AMP
)
725 snd_hdac_codec_write(&edev
->hdac
, nid
, 0,
726 AC_VERB_SET_AMP_GAIN_MUTE
, val
);
730 static int hdac_hdmi_pin_output_widget_event(struct snd_soc_dapm_widget
*w
,
731 struct snd_kcontrol
*kc
, int event
)
733 struct hdac_hdmi_port
*port
= w
->priv
;
734 struct hdac_ext_device
*edev
= to_hda_ext_device(w
->dapm
->dev
);
735 struct hdac_hdmi_pcm
*pcm
;
737 dev_dbg(&edev
->hdac
.dev
, "%s: widget: %s event: %x\n",
738 __func__
, w
->name
, event
);
740 pcm
= hdac_hdmi_get_pcm(edev
, port
);
744 /* set the device if pin is mst_capable */
745 if (hdac_hdmi_port_select_set(edev
, port
) < 0)
749 case SND_SOC_DAPM_PRE_PMU
:
750 hdac_hdmi_set_power_state(edev
, port
->pin
->nid
, AC_PWRST_D0
);
752 /* Enable out path for this pin widget */
753 snd_hdac_codec_write(&edev
->hdac
, port
->pin
->nid
, 0,
754 AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
);
756 hdac_hdmi_set_amp(edev
, port
->pin
->nid
, AMP_OUT_UNMUTE
);
758 return hdac_hdmi_setup_audio_infoframe(edev
, pcm
, port
);
760 case SND_SOC_DAPM_POST_PMD
:
761 hdac_hdmi_set_amp(edev
, port
->pin
->nid
, AMP_OUT_MUTE
);
763 /* Disable out path for this pin widget */
764 snd_hdac_codec_write(&edev
->hdac
, port
->pin
->nid
, 0,
765 AC_VERB_SET_PIN_WIDGET_CONTROL
, 0);
767 hdac_hdmi_set_power_state(edev
, port
->pin
->nid
, AC_PWRST_D3
);
775 static int hdac_hdmi_cvt_output_widget_event(struct snd_soc_dapm_widget
*w
,
776 struct snd_kcontrol
*kc
, int event
)
778 struct hdac_hdmi_cvt
*cvt
= w
->priv
;
779 struct hdac_ext_device
*edev
= to_hda_ext_device(w
->dapm
->dev
);
780 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
781 struct hdac_hdmi_pcm
*pcm
;
783 dev_dbg(&edev
->hdac
.dev
, "%s: widget: %s event: %x\n",
784 __func__
, w
->name
, event
);
786 pcm
= hdac_hdmi_get_pcm_from_cvt(hdmi
, cvt
);
791 case SND_SOC_DAPM_PRE_PMU
:
792 hdac_hdmi_set_power_state(edev
, cvt
->nid
, AC_PWRST_D0
);
794 /* Enable transmission */
795 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
796 AC_VERB_SET_DIGI_CONVERT_1
, 1);
798 /* Category Code (CC) to zero */
799 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
800 AC_VERB_SET_DIGI_CONVERT_2
, 0);
802 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
803 AC_VERB_SET_CHANNEL_STREAMID
, pcm
->stream_tag
);
804 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
805 AC_VERB_SET_STREAM_FORMAT
, pcm
->format
);
808 case SND_SOC_DAPM_POST_PMD
:
809 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
810 AC_VERB_SET_CHANNEL_STREAMID
, 0);
811 snd_hdac_codec_write(&edev
->hdac
, cvt
->nid
, 0,
812 AC_VERB_SET_STREAM_FORMAT
, 0);
814 hdac_hdmi_set_power_state(edev
, cvt
->nid
, AC_PWRST_D3
);
822 static int hdac_hdmi_pin_mux_widget_event(struct snd_soc_dapm_widget
*w
,
823 struct snd_kcontrol
*kc
, int event
)
825 struct hdac_hdmi_port
*port
= w
->priv
;
826 struct hdac_ext_device
*edev
= to_hda_ext_device(w
->dapm
->dev
);
829 dev_dbg(&edev
->hdac
.dev
, "%s: widget: %s event: %x\n",
830 __func__
, w
->name
, event
);
833 kc
= w
->kcontrols
[0];
835 mux_idx
= dapm_kcontrol_get_value(kc
);
837 /* set the device if pin is mst_capable */
838 if (hdac_hdmi_port_select_set(edev
, port
) < 0)
842 snd_hdac_codec_write(&edev
->hdac
, port
->pin
->nid
, 0,
843 AC_VERB_SET_CONNECT_SEL
, (mux_idx
- 1));
850 * Based on user selection, map the PINs with the PCMs.
852 static int hdac_hdmi_set_pin_port_mux(struct snd_kcontrol
*kcontrol
,
853 struct snd_ctl_elem_value
*ucontrol
)
856 struct hdac_hdmi_port
*p
, *p_next
;
857 struct soc_enum
*e
= (struct soc_enum
*)kcontrol
->private_value
;
858 struct snd_soc_dapm_widget
*w
= snd_soc_dapm_kcontrol_widget(kcontrol
);
859 struct snd_soc_dapm_context
*dapm
= w
->dapm
;
860 struct hdac_hdmi_port
*port
= w
->priv
;
861 struct hdac_ext_device
*edev
= to_hda_ext_device(dapm
->dev
);
862 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
863 struct hdac_hdmi_pcm
*pcm
= NULL
;
864 const char *cvt_name
= e
->texts
[ucontrol
->value
.enumerated
.item
[0]];
866 ret
= snd_soc_dapm_put_enum_double(kcontrol
, ucontrol
);
873 mutex_lock(&hdmi
->pin_mutex
);
874 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
875 if (list_empty(&pcm
->port_list
))
878 list_for_each_entry_safe(p
, p_next
, &pcm
->port_list
, head
) {
879 if (p
== port
&& p
->id
== port
->id
&&
880 p
->pin
== port
->pin
) {
881 hdac_hdmi_jack_report(pcm
, port
, false);
888 * Jack status is not reported during device probe as the
889 * PCMs are not registered by then. So report it here.
891 list_for_each_entry(pcm
, &hdmi
->pcm_list
, head
) {
892 if (!strcmp(cvt_name
, pcm
->cvt
->name
)) {
893 list_add_tail(&port
->head
, &pcm
->port_list
);
894 if (port
->eld
.monitor_present
&& port
->eld
.eld_valid
) {
895 hdac_hdmi_jack_report(pcm
, port
, true);
896 mutex_unlock(&hdmi
->pin_mutex
);
901 mutex_unlock(&hdmi
->pin_mutex
);
907 * Ideally the Mux inputs should be based on the num_muxs enumerated, but
908 * the display driver seem to be programming the connection list for the pin
911 * So programming all the possible inputs for the mux, the user has to take
912 * care of selecting the right one and leaving all other inputs selected to
915 static int hdac_hdmi_create_pin_port_muxs(struct hdac_ext_device
*edev
,
916 struct hdac_hdmi_port
*port
,
917 struct snd_soc_dapm_widget
*widget
,
918 const char *widget_name
)
920 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
921 struct hdac_hdmi_pin
*pin
= port
->pin
;
922 struct snd_kcontrol_new
*kc
;
923 struct hdac_hdmi_cvt
*cvt
;
925 char kc_name
[NAME_SIZE
];
926 char mux_items
[NAME_SIZE
];
927 /* To hold inputs to the Pin mux */
928 char *items
[HDA_MAX_CONNECTIONS
];
930 int num_items
= hdmi
->num_cvt
+ 1;
932 kc
= devm_kzalloc(&edev
->hdac
.dev
, sizeof(*kc
), GFP_KERNEL
);
936 se
= devm_kzalloc(&edev
->hdac
.dev
, sizeof(*se
), GFP_KERNEL
);
940 sprintf(kc_name
, "Pin %d port %d Input", pin
->nid
, port
->id
);
941 kc
->name
= devm_kstrdup(&edev
->hdac
.dev
, kc_name
, GFP_KERNEL
);
945 kc
->private_value
= (long)se
;
946 kc
->iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
948 kc
->info
= snd_soc_info_enum_double
;
949 kc
->put
= hdac_hdmi_set_pin_port_mux
;
950 kc
->get
= snd_soc_dapm_get_enum_double
;
952 se
->reg
= SND_SOC_NOPM
;
954 /* enum texts: ["NONE", "cvt #", "cvt #", ...] */
955 se
->items
= num_items
;
956 se
->mask
= roundup_pow_of_two(se
->items
) - 1;
958 sprintf(mux_items
, "NONE");
959 items
[i
] = devm_kstrdup(&edev
->hdac
.dev
, mux_items
, GFP_KERNEL
);
963 list_for_each_entry(cvt
, &hdmi
->cvt_list
, head
) {
965 sprintf(mux_items
, "cvt %d", cvt
->nid
);
966 items
[i
] = devm_kstrdup(&edev
->hdac
.dev
, mux_items
, GFP_KERNEL
);
971 se
->texts
= devm_kmemdup(&edev
->hdac
.dev
, items
,
972 (num_items
* sizeof(char *)), GFP_KERNEL
);
976 return hdac_hdmi_fill_widget_info(&edev
->hdac
.dev
, widget
,
977 snd_soc_dapm_mux
, port
, widget_name
, NULL
, kc
, 1,
978 hdac_hdmi_pin_mux_widget_event
,
979 SND_SOC_DAPM_PRE_PMU
| SND_SOC_DAPM_POST_REG
);
982 /* Add cvt <- input <- mux route map */
983 static void hdac_hdmi_add_pinmux_cvt_route(struct hdac_ext_device
*edev
,
984 struct snd_soc_dapm_widget
*widgets
,
985 struct snd_soc_dapm_route
*route
, int rindex
)
987 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
988 const struct snd_kcontrol_new
*kc
;
990 int mux_index
= hdmi
->num_cvt
+ hdmi
->num_ports
;
993 for (i
= 0; i
< hdmi
->num_ports
; i
++) {
994 kc
= widgets
[mux_index
].kcontrol_news
;
995 se
= (struct soc_enum
*)kc
->private_value
;
996 for (j
= 0; j
< hdmi
->num_cvt
; j
++) {
997 hdac_hdmi_fill_route(&route
[rindex
],
998 widgets
[mux_index
].name
,
1000 widgets
[j
].name
, NULL
);
1010 * Widgets are added in the below sequence
1011 * Converter widgets for num converters enumerated
1012 * Pin-port widgets for num ports for Pins enumerated
1013 * Pin-port mux widgets to represent connenction list of pin widget
1015 * For each port, one Mux and One output widget is added
1016 * Total widgets elements = num_cvt + (num_ports * 2);
1018 * Routes are added as below:
1019 * pin-port mux -> pin (based on num_ports)
1020 * cvt -> "Input sel control" -> pin-port_mux
1022 * Total route elements:
1023 * num_ports + (pin_muxes * num_cvt)
1025 static int create_fill_widget_route_map(struct snd_soc_dapm_context
*dapm
)
1027 struct snd_soc_dapm_widget
*widgets
;
1028 struct snd_soc_dapm_route
*route
;
1029 struct hdac_ext_device
*edev
= to_hda_ext_device(dapm
->dev
);
1030 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1031 struct snd_soc_dai_driver
*dai_drv
= dapm
->component
->dai_drv
;
1032 char widget_name
[NAME_SIZE
];
1033 struct hdac_hdmi_cvt
*cvt
;
1034 struct hdac_hdmi_pin
*pin
;
1035 int ret
, i
= 0, num_routes
= 0, j
;
1037 if (list_empty(&hdmi
->cvt_list
) || list_empty(&hdmi
->pin_list
))
1040 widgets
= devm_kzalloc(dapm
->dev
, (sizeof(*widgets
) *
1041 ((2 * hdmi
->num_ports
) + hdmi
->num_cvt
)),
1047 /* DAPM widgets to represent each converter widget */
1048 list_for_each_entry(cvt
, &hdmi
->cvt_list
, head
) {
1049 sprintf(widget_name
, "Converter %d", cvt
->nid
);
1050 ret
= hdac_hdmi_fill_widget_info(dapm
->dev
, &widgets
[i
],
1051 snd_soc_dapm_aif_in
, cvt
,
1052 widget_name
, dai_drv
[i
].playback
.stream_name
, NULL
, 0,
1053 hdac_hdmi_cvt_output_widget_event
,
1054 SND_SOC_DAPM_PRE_PMU
| SND_SOC_DAPM_POST_PMD
);
1060 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1061 for (j
= 0; j
< pin
->num_ports
; j
++) {
1062 sprintf(widget_name
, "hif%d-%d Output",
1063 pin
->nid
, pin
->ports
[j
].id
);
1064 ret
= hdac_hdmi_fill_widget_info(dapm
->dev
, &widgets
[i
],
1065 snd_soc_dapm_output
, &pin
->ports
[j
],
1066 widget_name
, NULL
, NULL
, 0,
1067 hdac_hdmi_pin_output_widget_event
,
1068 SND_SOC_DAPM_PRE_PMU
|
1069 SND_SOC_DAPM_POST_PMD
);
1072 pin
->ports
[j
].output_pin
= widgets
[i
].name
;
1077 /* DAPM widgets to represent the connection list to pin widget */
1078 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1079 for (j
= 0; j
< pin
->num_ports
; j
++) {
1080 sprintf(widget_name
, "Pin%d-Port%d Mux",
1081 pin
->nid
, pin
->ports
[j
].id
);
1082 ret
= hdac_hdmi_create_pin_port_muxs(edev
,
1083 &pin
->ports
[j
], &widgets
[i
],
1089 /* For cvt to pin_mux mapping */
1090 num_routes
+= hdmi
->num_cvt
;
1092 /* For pin_mux to pin mapping */
1097 route
= devm_kzalloc(dapm
->dev
, (sizeof(*route
) * num_routes
),
1103 /* Add pin <- NULL <- mux route map */
1104 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1105 for (j
= 0; j
< pin
->num_ports
; j
++) {
1106 int sink_index
= i
+ hdmi
->num_cvt
;
1107 int src_index
= sink_index
+ pin
->num_ports
*
1110 hdac_hdmi_fill_route(&route
[i
],
1111 widgets
[sink_index
].name
, NULL
,
1112 widgets
[src_index
].name
, NULL
);
1117 hdac_hdmi_add_pinmux_cvt_route(edev
, widgets
, route
, i
);
1119 snd_soc_dapm_new_controls(dapm
, widgets
,
1120 ((2 * hdmi
->num_ports
) + hdmi
->num_cvt
));
1122 snd_soc_dapm_add_routes(dapm
, route
, num_routes
);
1123 snd_soc_dapm_new_widgets(dapm
->card
);
1129 static int hdac_hdmi_init_dai_map(struct hdac_ext_device
*edev
)
1131 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1132 struct hdac_hdmi_dai_port_map
*dai_map
;
1133 struct hdac_hdmi_cvt
*cvt
;
1136 if (list_empty(&hdmi
->cvt_list
))
1139 list_for_each_entry(cvt
, &hdmi
->cvt_list
, head
) {
1140 dai_map
= &hdmi
->dai_map
[dai_id
];
1141 dai_map
->dai_id
= dai_id
;
1146 if (dai_id
== HDA_MAX_CVTS
) {
1147 dev_warn(&edev
->hdac
.dev
,
1148 "Max dais supported: %d\n", dai_id
);
1156 static int hdac_hdmi_add_cvt(struct hdac_ext_device
*edev
, hda_nid_t nid
)
1158 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1159 struct hdac_hdmi_cvt
*cvt
;
1160 char name
[NAME_SIZE
];
1162 cvt
= kzalloc(sizeof(*cvt
), GFP_KERNEL
);
1167 sprintf(name
, "cvt %d", cvt
->nid
);
1168 cvt
->name
= kstrdup(name
, GFP_KERNEL
);
1170 list_add_tail(&cvt
->head
, &hdmi
->cvt_list
);
1173 return hdac_hdmi_query_cvt_params(&edev
->hdac
, cvt
);
1176 static int hdac_hdmi_parse_eld(struct hdac_ext_device
*edev
,
1177 struct hdac_hdmi_port
*port
)
1179 unsigned int ver
, mnl
;
1181 ver
= (port
->eld
.eld_buffer
[DRM_ELD_VER
] & DRM_ELD_VER_MASK
)
1182 >> DRM_ELD_VER_SHIFT
;
1184 if (ver
!= ELD_VER_CEA_861D
&& ver
!= ELD_VER_PARTIAL
) {
1185 dev_err(&edev
->hdac
.dev
, "HDMI: Unknown ELD version %d\n", ver
);
1189 mnl
= (port
->eld
.eld_buffer
[DRM_ELD_CEA_EDID_VER_MNL
] &
1190 DRM_ELD_MNL_MASK
) >> DRM_ELD_MNL_SHIFT
;
1192 if (mnl
> ELD_MAX_MNL
) {
1193 dev_err(&edev
->hdac
.dev
, "HDMI: MNL Invalid %d\n", mnl
);
1197 port
->eld
.info
.spk_alloc
= port
->eld
.eld_buffer
[DRM_ELD_SPEAKER
];
1202 static void hdac_hdmi_present_sense(struct hdac_hdmi_pin
*pin
,
1203 struct hdac_hdmi_port
*port
)
1205 struct hdac_ext_device
*edev
= pin
->edev
;
1206 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1207 struct hdac_hdmi_pcm
*pcm
;
1215 * In case of non MST pin, get_eld info API expectes port
1218 mutex_lock(&hdmi
->pin_mutex
);
1219 port
->eld
.monitor_present
= false;
1221 if (pin
->mst_capable
)
1224 size
= snd_hdac_acomp_get_eld(&edev
->hdac
, pin
->nid
, port_id
,
1225 &port
->eld
.monitor_present
,
1226 port
->eld
.eld_buffer
,
1230 size
= min(size
, ELD_MAX_SIZE
);
1231 if (hdac_hdmi_parse_eld(edev
, port
) < 0)
1236 port
->eld
.eld_valid
= true;
1237 port
->eld
.eld_size
= size
;
1239 port
->eld
.eld_valid
= false;
1240 port
->eld
.eld_size
= 0;
1243 pcm
= hdac_hdmi_get_pcm(edev
, port
);
1245 if (!port
->eld
.monitor_present
|| !port
->eld
.eld_valid
) {
1247 dev_err(&edev
->hdac
.dev
, "%s: disconnect for pin:port %d:%d\n",
1248 __func__
, pin
->nid
, port
->id
);
1251 * PCMs are not registered during device probe, so don't
1252 * report jack here. It will be done in usermode mux
1256 hdac_hdmi_jack_report(pcm
, port
, false);
1258 mutex_unlock(&hdmi
->pin_mutex
);
1262 if (port
->eld
.monitor_present
&& port
->eld
.eld_valid
) {
1264 hdac_hdmi_jack_report(pcm
, port
, true);
1266 print_hex_dump_debug("ELD: ", DUMP_PREFIX_OFFSET
, 16, 1,
1267 port
->eld
.eld_buffer
, port
->eld
.eld_size
, false);
1270 mutex_unlock(&hdmi
->pin_mutex
);
1273 static int hdac_hdmi_add_ports(struct hdac_hdmi_priv
*hdmi
,
1274 struct hdac_hdmi_pin
*pin
)
1276 struct hdac_hdmi_port
*ports
;
1277 int max_ports
= HDA_MAX_PORTS
;
1281 * FIXME: max_port may vary for each platform, so pass this as
1282 * as driver data or query from i915 interface when this API is
1286 ports
= kcalloc(max_ports
, sizeof(*ports
), GFP_KERNEL
);
1290 for (i
= 0; i
< max_ports
; i
++) {
1295 pin
->num_ports
= max_ports
;
1299 static int hdac_hdmi_add_pin(struct hdac_ext_device
*edev
, hda_nid_t nid
)
1301 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1302 struct hdac_hdmi_pin
*pin
;
1305 pin
= kzalloc(sizeof(*pin
), GFP_KERNEL
);
1310 pin
->mst_capable
= false;
1312 ret
= hdac_hdmi_add_ports(hdmi
, pin
);
1316 list_add_tail(&pin
->head
, &hdmi
->pin_list
);
1318 hdmi
->num_ports
+= pin
->num_ports
;
1323 #define INTEL_VENDOR_NID 0x08
1324 #define INTEL_GET_VENDOR_VERB 0xf81
1325 #define INTEL_SET_VENDOR_VERB 0x781
1326 #define INTEL_EN_DP12 0x02 /* enable DP 1.2 features */
1327 #define INTEL_EN_ALL_PIN_CVTS 0x01 /* enable 2nd & 3rd pins and convertors */
1329 static void hdac_hdmi_skl_enable_all_pins(struct hdac_device
*hdac
)
1331 unsigned int vendor_param
;
1333 vendor_param
= snd_hdac_codec_read(hdac
, INTEL_VENDOR_NID
, 0,
1334 INTEL_GET_VENDOR_VERB
, 0);
1335 if (vendor_param
== -1 || vendor_param
& INTEL_EN_ALL_PIN_CVTS
)
1338 vendor_param
|= INTEL_EN_ALL_PIN_CVTS
;
1339 vendor_param
= snd_hdac_codec_read(hdac
, INTEL_VENDOR_NID
, 0,
1340 INTEL_SET_VENDOR_VERB
, vendor_param
);
1341 if (vendor_param
== -1)
1345 static void hdac_hdmi_skl_enable_dp12(struct hdac_device
*hdac
)
1347 unsigned int vendor_param
;
1349 vendor_param
= snd_hdac_codec_read(hdac
, INTEL_VENDOR_NID
, 0,
1350 INTEL_GET_VENDOR_VERB
, 0);
1351 if (vendor_param
== -1 || vendor_param
& INTEL_EN_DP12
)
1354 /* enable DP1.2 mode */
1355 vendor_param
|= INTEL_EN_DP12
;
1356 vendor_param
= snd_hdac_codec_read(hdac
, INTEL_VENDOR_NID
, 0,
1357 INTEL_SET_VENDOR_VERB
, vendor_param
);
1358 if (vendor_param
== -1)
1363 static struct snd_soc_dai_ops hdmi_dai_ops
= {
1364 .startup
= hdac_hdmi_pcm_open
,
1365 .shutdown
= hdac_hdmi_pcm_close
,
1366 .hw_params
= hdac_hdmi_set_hw_params
,
1367 .set_tdm_slot
= hdac_hdmi_set_tdm_slot
,
1371 * Each converter can support a stream independently. So a dai is created
1372 * based on the number of converter queried.
1374 static int hdac_hdmi_create_dais(struct hdac_device
*hdac
,
1375 struct snd_soc_dai_driver
**dais
,
1376 struct hdac_hdmi_priv
*hdmi
, int num_dais
)
1378 struct snd_soc_dai_driver
*hdmi_dais
;
1379 struct hdac_hdmi_cvt
*cvt
;
1380 char name
[NAME_SIZE
], dai_name
[NAME_SIZE
];
1383 unsigned int rate_max
= 384000, rate_min
= 8000;
1387 hdmi_dais
= devm_kzalloc(&hdac
->dev
,
1388 (sizeof(*hdmi_dais
) * num_dais
),
1393 list_for_each_entry(cvt
, &hdmi
->cvt_list
, head
) {
1394 ret
= snd_hdac_query_supported_pcm(hdac
, cvt
->nid
,
1395 &rates
, &formats
, &bps
);
1399 sprintf(dai_name
, "intel-hdmi-hifi%d", i
+1);
1400 hdmi_dais
[i
].name
= devm_kstrdup(&hdac
->dev
,
1401 dai_name
, GFP_KERNEL
);
1403 if (!hdmi_dais
[i
].name
)
1406 snprintf(name
, sizeof(name
), "hifi%d", i
+1);
1407 hdmi_dais
[i
].playback
.stream_name
=
1408 devm_kstrdup(&hdac
->dev
, name
, GFP_KERNEL
);
1409 if (!hdmi_dais
[i
].playback
.stream_name
)
1413 * Set caps based on capability queried from the converter.
1414 * It will be constrained runtime based on ELD queried.
1416 hdmi_dais
[i
].playback
.formats
= formats
;
1417 hdmi_dais
[i
].playback
.rates
= rates
;
1418 hdmi_dais
[i
].playback
.rate_max
= rate_max
;
1419 hdmi_dais
[i
].playback
.rate_min
= rate_min
;
1420 hdmi_dais
[i
].playback
.channels_min
= 2;
1421 hdmi_dais
[i
].playback
.channels_max
= 2;
1422 hdmi_dais
[i
].ops
= &hdmi_dai_ops
;
1433 * Parse all nodes and store the cvt/pin nids in array
1434 * Add one time initialization for pin and cvt widgets
1436 static int hdac_hdmi_parse_and_map_nid(struct hdac_ext_device
*edev
,
1437 struct snd_soc_dai_driver
**dais
, int *num_dais
)
1441 struct hdac_device
*hdac
= &edev
->hdac
;
1442 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1445 hdac_hdmi_skl_enable_all_pins(hdac
);
1446 hdac_hdmi_skl_enable_dp12(hdac
);
1448 num_nodes
= snd_hdac_get_sub_nodes(hdac
, hdac
->afg
, &nid
);
1449 if (!nid
|| num_nodes
<= 0) {
1450 dev_warn(&hdac
->dev
, "HDMI: failed to get afg sub nodes\n");
1454 hdac
->num_nodes
= num_nodes
;
1455 hdac
->start_nid
= nid
;
1457 for (i
= 0; i
< hdac
->num_nodes
; i
++, nid
++) {
1461 caps
= get_wcaps(hdac
, nid
);
1462 type
= get_wcaps_type(caps
);
1464 if (!(caps
& AC_WCAP_DIGITAL
))
1469 case AC_WID_AUD_OUT
:
1470 ret
= hdac_hdmi_add_cvt(edev
, nid
);
1476 ret
= hdac_hdmi_add_pin(edev
, nid
);
1483 hdac
->end_nid
= nid
;
1485 if (!hdmi
->num_pin
|| !hdmi
->num_cvt
)
1488 ret
= hdac_hdmi_create_dais(hdac
, dais
, hdmi
, hdmi
->num_cvt
);
1490 dev_err(&hdac
->dev
, "Failed to create dais with err: %d\n",
1495 *num_dais
= hdmi
->num_cvt
;
1497 return hdac_hdmi_init_dai_map(edev
);
1500 static void hdac_hdmi_eld_notify_cb(void *aptr
, int port
, int pipe
)
1502 struct hdac_ext_device
*edev
= aptr
;
1503 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1504 struct hdac_hdmi_pin
*pin
= NULL
;
1505 struct hdac_hdmi_port
*hport
= NULL
;
1506 struct snd_soc_codec
*codec
= edev
->scodec
;
1509 /* Don't know how this mapping is derived */
1510 hda_nid_t pin_nid
= port
+ 0x04;
1512 dev_dbg(&edev
->hdac
.dev
, "%s: for pin:%d port=%d\n", __func__
,
1516 * skip notification during system suspend (but not in runtime PM);
1517 * the state will be updated at resume. Also since the ELD and
1518 * connection states are updated in anyway at the end of the resume,
1519 * we can skip it when received during PM process.
1521 if (snd_power_get_state(codec
->component
.card
->snd_card
) !=
1525 if (atomic_read(&edev
->hdac
.in_pm
))
1528 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1529 if (pin
->nid
!= pin_nid
)
1532 /* In case of non MST pin, pipe is -1 */
1534 pin
->mst_capable
= false;
1535 /* if not MST, default is port[0] */
1536 hport
= &pin
->ports
[0];
1539 for (i
= 0; i
< pin
->num_ports
; i
++) {
1540 pin
->mst_capable
= true;
1541 if (pin
->ports
[i
].id
== pipe
) {
1542 hport
= &pin
->ports
[i
];
1551 hdac_hdmi_present_sense(pin
, hport
);
1554 static struct i915_audio_component_audio_ops aops
= {
1555 .pin_eld_notify
= hdac_hdmi_eld_notify_cb
,
1558 static struct snd_pcm
*hdac_hdmi_get_pcm_from_id(struct snd_soc_card
*card
,
1561 struct snd_soc_pcm_runtime
*rtd
;
1563 list_for_each_entry(rtd
, &card
->rtd_list
, list
) {
1564 if (rtd
->pcm
&& (rtd
->pcm
->device
== device
))
1571 /* create jack pin kcontrols */
1572 static int create_fill_jack_kcontrols(struct snd_soc_card
*card
,
1573 struct hdac_ext_device
*edev
)
1575 struct hdac_hdmi_pin
*pin
;
1576 struct snd_kcontrol_new
*kc
;
1577 char kc_name
[NAME_SIZE
], xname
[NAME_SIZE
];
1580 struct snd_soc_codec
*codec
= edev
->scodec
;
1581 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1583 kc
= devm_kcalloc(codec
->dev
, hdmi
->num_ports
,
1584 sizeof(*kc
), GFP_KERNEL
);
1589 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1590 for (j
= 0; j
< pin
->num_ports
; j
++) {
1591 snprintf(xname
, sizeof(xname
), "hif%d-%d Jack",
1592 pin
->nid
, pin
->ports
[j
].id
);
1593 name
= devm_kstrdup(codec
->dev
, xname
, GFP_KERNEL
);
1596 snprintf(kc_name
, sizeof(kc_name
), "%s Switch", xname
);
1597 kc
[i
].name
= devm_kstrdup(codec
->dev
, kc_name
,
1602 kc
[i
].private_value
= (unsigned long)name
;
1603 kc
[i
].iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
1605 kc
[i
].info
= snd_soc_dapm_info_pin_switch
;
1606 kc
[i
].put
= snd_soc_dapm_put_pin_switch
;
1607 kc
[i
].get
= snd_soc_dapm_get_pin_switch
;
1612 return snd_soc_add_card_controls(card
, kc
, i
);
1615 int hdac_hdmi_jack_port_init(struct snd_soc_codec
*codec
,
1616 struct snd_soc_dapm_context
*dapm
)
1618 struct hdac_ext_device
*edev
= snd_soc_codec_get_drvdata(codec
);
1619 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1620 struct hdac_hdmi_pin
*pin
;
1621 struct snd_soc_dapm_widget
*widgets
;
1622 struct snd_soc_dapm_route
*route
;
1623 char w_name
[NAME_SIZE
];
1626 widgets
= devm_kcalloc(dapm
->dev
, hdmi
->num_ports
,
1627 sizeof(*widgets
), GFP_KERNEL
);
1632 route
= devm_kcalloc(dapm
->dev
, hdmi
->num_ports
,
1633 sizeof(*route
), GFP_KERNEL
);
1637 /* create Jack DAPM widget */
1638 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1639 for (j
= 0; j
< pin
->num_ports
; j
++) {
1640 snprintf(w_name
, sizeof(w_name
), "hif%d-%d Jack",
1641 pin
->nid
, pin
->ports
[j
].id
);
1643 ret
= hdac_hdmi_fill_widget_info(dapm
->dev
, &widgets
[i
],
1644 snd_soc_dapm_spk
, NULL
,
1645 w_name
, NULL
, NULL
, 0, NULL
, 0);
1649 pin
->ports
[j
].jack_pin
= widgets
[i
].name
;
1650 pin
->ports
[j
].dapm
= dapm
;
1652 /* add to route from Jack widget to output */
1653 hdac_hdmi_fill_route(&route
[i
], pin
->ports
[j
].jack_pin
,
1654 NULL
, pin
->ports
[j
].output_pin
, NULL
);
1660 /* Add Route from Jack widget to the output widget */
1661 ret
= snd_soc_dapm_new_controls(dapm
, widgets
, hdmi
->num_ports
);
1665 ret
= snd_soc_dapm_add_routes(dapm
, route
, hdmi
->num_ports
);
1669 ret
= snd_soc_dapm_new_widgets(dapm
->card
);
1673 /* Add Jack Pin switch Kcontrol */
1674 ret
= create_fill_jack_kcontrols(dapm
->card
, edev
);
1679 /* default set the Jack Pin switch to OFF */
1680 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1681 for (j
= 0; j
< pin
->num_ports
; j
++)
1682 snd_soc_dapm_disable_pin(pin
->ports
[j
].dapm
,
1683 pin
->ports
[j
].jack_pin
);
1688 EXPORT_SYMBOL_GPL(hdac_hdmi_jack_port_init
);
1690 int hdac_hdmi_jack_init(struct snd_soc_dai
*dai
, int device
,
1691 struct snd_soc_jack
*jack
)
1693 struct snd_soc_codec
*codec
= dai
->codec
;
1694 struct hdac_ext_device
*edev
= snd_soc_codec_get_drvdata(codec
);
1695 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1696 struct hdac_hdmi_pcm
*pcm
;
1697 struct snd_pcm
*snd_pcm
;
1701 * this is a new PCM device, create new pcm and
1702 * add to the pcm list
1704 pcm
= kzalloc(sizeof(*pcm
), GFP_KERNEL
);
1707 pcm
->pcm_id
= device
;
1708 pcm
->cvt
= hdmi
->dai_map
[dai
->id
].cvt
;
1709 pcm
->jack_event
= 0;
1711 mutex_init(&pcm
->lock
);
1712 INIT_LIST_HEAD(&pcm
->port_list
);
1713 snd_pcm
= hdac_hdmi_get_pcm_from_id(dai
->component
->card
, device
);
1715 err
= snd_hdac_add_chmap_ctls(snd_pcm
, device
, &hdmi
->chmap
);
1717 dev_err(&edev
->hdac
.dev
,
1718 "chmap control add failed with err: %d for pcm: %d\n",
1725 list_add_tail(&pcm
->head
, &hdmi
->pcm_list
);
1729 EXPORT_SYMBOL_GPL(hdac_hdmi_jack_init
);
1731 static void hdac_hdmi_present_sense_all_pins(struct hdac_ext_device
*edev
,
1732 struct hdac_hdmi_priv
*hdmi
, bool detect_pin_caps
)
1735 struct hdac_hdmi_pin
*pin
;
1737 list_for_each_entry(pin
, &hdmi
->pin_list
, head
) {
1738 if (detect_pin_caps
) {
1740 if (hdac_hdmi_get_port_len(edev
, pin
->nid
) == 0)
1741 pin
->mst_capable
= false;
1743 pin
->mst_capable
= true;
1746 for (i
= 0; i
< pin
->num_ports
; i
++) {
1747 if (!pin
->mst_capable
&& i
> 0)
1750 hdac_hdmi_present_sense(pin
, &pin
->ports
[i
]);
1755 static int hdmi_codec_probe(struct snd_soc_codec
*codec
)
1757 struct hdac_ext_device
*edev
= snd_soc_codec_get_drvdata(codec
);
1758 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1759 struct snd_soc_dapm_context
*dapm
=
1760 snd_soc_component_get_dapm(&codec
->component
);
1761 struct hdac_ext_link
*hlink
= NULL
;
1764 edev
->scodec
= codec
;
1767 * hold the ref while we probe, also no need to drop the ref on
1768 * exit, we call pm_runtime_suspend() so that will do for us
1770 hlink
= snd_hdac_ext_bus_get_link(edev
->ebus
, dev_name(&edev
->hdac
.dev
));
1772 dev_err(&edev
->hdac
.dev
, "hdac link not found\n");
1776 snd_hdac_ext_bus_link_get(edev
->ebus
, hlink
);
1778 ret
= create_fill_widget_route_map(dapm
);
1782 aops
.audio_ptr
= edev
;
1783 ret
= snd_hdac_i915_register_notifier(&aops
);
1785 dev_err(&edev
->hdac
.dev
, "notifier register failed: err: %d\n",
1790 hdac_hdmi_present_sense_all_pins(edev
, hdmi
, true);
1791 /* Imp: Store the card pointer in hda_codec */
1792 edev
->card
= dapm
->card
->snd_card
;
1795 * hdac_device core already sets the state to active and calls
1796 * get_noresume. So enable runtime and set the device to suspend.
1798 pm_runtime_enable(&edev
->hdac
.dev
);
1799 pm_runtime_put(&edev
->hdac
.dev
);
1800 pm_runtime_suspend(&edev
->hdac
.dev
);
1805 static int hdmi_codec_remove(struct snd_soc_codec
*codec
)
1807 struct hdac_ext_device
*edev
= snd_soc_codec_get_drvdata(codec
);
1809 pm_runtime_disable(&edev
->hdac
.dev
);
1814 static int hdmi_codec_prepare(struct device
*dev
)
1816 struct hdac_ext_device
*edev
= to_hda_ext_device(dev
);
1817 struct hdac_device
*hdac
= &edev
->hdac
;
1819 pm_runtime_get_sync(&edev
->hdac
.dev
);
1823 * codec_read is preferred over codec_write to set the power state.
1824 * This way verb is send to set the power state and response
1825 * is received. So setting power state is ensured without using loop
1826 * to read the state.
1828 snd_hdac_codec_read(hdac
, hdac
->afg
, 0, AC_VERB_SET_POWER_STATE
,
1834 static void hdmi_codec_complete(struct device
*dev
)
1836 struct hdac_ext_device
*edev
= to_hda_ext_device(dev
);
1837 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1838 struct hdac_device
*hdac
= &edev
->hdac
;
1841 snd_hdac_codec_read(hdac
, hdac
->afg
, 0, AC_VERB_SET_POWER_STATE
,
1844 hdac_hdmi_skl_enable_all_pins(&edev
->hdac
);
1845 hdac_hdmi_skl_enable_dp12(&edev
->hdac
);
1848 * As the ELD notify callback request is not entertained while the
1849 * device is in suspend state. Need to manually check detection of
1850 * all pins here. pin capablity change is not support, so use the
1851 * already set pin caps.
1853 hdac_hdmi_present_sense_all_pins(edev
, hdmi
, false);
1855 pm_runtime_put_sync(&edev
->hdac
.dev
);
1858 #define hdmi_codec_prepare NULL
1859 #define hdmi_codec_complete NULL
1862 static struct snd_soc_codec_driver hdmi_hda_codec
= {
1863 .probe
= hdmi_codec_probe
,
1864 .remove
= hdmi_codec_remove
,
1865 .idle_bias_off
= true,
1868 static void hdac_hdmi_get_chmap(struct hdac_device
*hdac
, int pcm_idx
,
1869 unsigned char *chmap
)
1871 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
1872 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1873 struct hdac_hdmi_pcm
*pcm
= get_hdmi_pcm_from_id(hdmi
, pcm_idx
);
1875 memcpy(chmap
, pcm
->chmap
, ARRAY_SIZE(pcm
->chmap
));
1878 static void hdac_hdmi_set_chmap(struct hdac_device
*hdac
, int pcm_idx
,
1879 unsigned char *chmap
, int prepared
)
1881 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
1882 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1883 struct hdac_hdmi_pcm
*pcm
= get_hdmi_pcm_from_id(hdmi
, pcm_idx
);
1884 struct hdac_hdmi_port
*port
;
1886 if (list_empty(&pcm
->port_list
))
1889 mutex_lock(&pcm
->lock
);
1890 pcm
->chmap_set
= true;
1891 memcpy(pcm
->chmap
, chmap
, ARRAY_SIZE(pcm
->chmap
));
1892 list_for_each_entry(port
, &pcm
->port_list
, head
)
1894 hdac_hdmi_setup_audio_infoframe(edev
, pcm
, port
);
1895 mutex_unlock(&pcm
->lock
);
1898 static bool is_hdac_hdmi_pcm_attached(struct hdac_device
*hdac
, int pcm_idx
)
1900 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
1901 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1902 struct hdac_hdmi_pcm
*pcm
= get_hdmi_pcm_from_id(hdmi
, pcm_idx
);
1904 if (list_empty(&pcm
->port_list
))
1910 static int hdac_hdmi_get_spk_alloc(struct hdac_device
*hdac
, int pcm_idx
)
1912 struct hdac_ext_device
*edev
= to_ehdac_device(hdac
);
1913 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1914 struct hdac_hdmi_pcm
*pcm
= get_hdmi_pcm_from_id(hdmi
, pcm_idx
);
1915 struct hdac_hdmi_port
*port
;
1917 if (list_empty(&pcm
->port_list
))
1920 port
= list_first_entry(&pcm
->port_list
, struct hdac_hdmi_port
, head
);
1925 if (!port
|| !port
->eld
.eld_valid
)
1928 return port
->eld
.info
.spk_alloc
;
1931 static int hdac_hdmi_dev_probe(struct hdac_ext_device
*edev
)
1933 struct hdac_device
*codec
= &edev
->hdac
;
1934 struct hdac_hdmi_priv
*hdmi_priv
;
1935 struct snd_soc_dai_driver
*hdmi_dais
= NULL
;
1936 struct hdac_ext_link
*hlink
= NULL
;
1940 /* hold the ref while we probe */
1941 hlink
= snd_hdac_ext_bus_get_link(edev
->ebus
, dev_name(&edev
->hdac
.dev
));
1943 dev_err(&edev
->hdac
.dev
, "hdac link not found\n");
1947 snd_hdac_ext_bus_link_get(edev
->ebus
, hlink
);
1949 hdmi_priv
= devm_kzalloc(&codec
->dev
, sizeof(*hdmi_priv
), GFP_KERNEL
);
1950 if (hdmi_priv
== NULL
)
1953 edev
->private_data
= hdmi_priv
;
1954 snd_hdac_register_chmap_ops(codec
, &hdmi_priv
->chmap
);
1955 hdmi_priv
->chmap
.ops
.get_chmap
= hdac_hdmi_get_chmap
;
1956 hdmi_priv
->chmap
.ops
.set_chmap
= hdac_hdmi_set_chmap
;
1957 hdmi_priv
->chmap
.ops
.is_pcm_attached
= is_hdac_hdmi_pcm_attached
;
1958 hdmi_priv
->chmap
.ops
.get_spk_alloc
= hdac_hdmi_get_spk_alloc
;
1960 dev_set_drvdata(&codec
->dev
, edev
);
1962 INIT_LIST_HEAD(&hdmi_priv
->pin_list
);
1963 INIT_LIST_HEAD(&hdmi_priv
->cvt_list
);
1964 INIT_LIST_HEAD(&hdmi_priv
->pcm_list
);
1965 mutex_init(&hdmi_priv
->pin_mutex
);
1968 * Turned off in the runtime_suspend during the first explicit
1969 * pm_runtime_suspend call.
1971 ret
= snd_hdac_display_power(edev
->hdac
.bus
, true);
1973 dev_err(&edev
->hdac
.dev
,
1974 "Cannot turn on display power on i915 err: %d\n",
1979 ret
= hdac_hdmi_parse_and_map_nid(edev
, &hdmi_dais
, &num_dais
);
1981 dev_err(&codec
->dev
,
1982 "Failed in parse and map nid with err: %d\n", ret
);
1986 /* ASoC specific initialization */
1987 ret
= snd_soc_register_codec(&codec
->dev
, &hdmi_hda_codec
,
1988 hdmi_dais
, num_dais
);
1990 snd_hdac_ext_bus_link_put(edev
->ebus
, hlink
);
1995 static int hdac_hdmi_dev_remove(struct hdac_ext_device
*edev
)
1997 struct hdac_hdmi_priv
*hdmi
= edev
->private_data
;
1998 struct hdac_hdmi_pin
*pin
, *pin_next
;
1999 struct hdac_hdmi_cvt
*cvt
, *cvt_next
;
2000 struct hdac_hdmi_pcm
*pcm
, *pcm_next
;
2001 struct hdac_hdmi_port
*port
;
2004 snd_soc_unregister_codec(&edev
->hdac
.dev
);
2006 list_for_each_entry_safe(pcm
, pcm_next
, &hdmi
->pcm_list
, head
) {
2008 if (list_empty(&pcm
->port_list
))
2011 list_for_each_entry(port
, &pcm
->port_list
, head
)
2014 list_del(&pcm
->head
);
2018 list_for_each_entry_safe(cvt
, cvt_next
, &hdmi
->cvt_list
, head
) {
2019 list_del(&cvt
->head
);
2024 list_for_each_entry_safe(pin
, pin_next
, &hdmi
->pin_list
, head
) {
2025 for (i
= 0; i
< pin
->num_ports
; i
++)
2026 pin
->ports
[i
].pin
= NULL
;
2028 list_del(&pin
->head
);
2036 static int hdac_hdmi_runtime_suspend(struct device
*dev
)
2038 struct hdac_ext_device
*edev
= to_hda_ext_device(dev
);
2039 struct hdac_device
*hdac
= &edev
->hdac
;
2040 struct hdac_bus
*bus
= hdac
->bus
;
2041 struct hdac_ext_bus
*ebus
= hbus_to_ebus(bus
);
2042 struct hdac_ext_link
*hlink
= NULL
;
2045 dev_dbg(dev
, "Enter: %s\n", __func__
);
2047 /* controller may not have been initialized for the first time */
2053 * codec_read is preferred over codec_write to set the power state.
2054 * This way verb is send to set the power state and response
2055 * is received. So setting power state is ensured without using loop
2056 * to read the state.
2058 snd_hdac_codec_read(hdac
, hdac
->afg
, 0, AC_VERB_SET_POWER_STATE
,
2060 err
= snd_hdac_display_power(bus
, false);
2062 dev_err(bus
->dev
, "Cannot turn on display power on i915\n");
2066 hlink
= snd_hdac_ext_bus_get_link(ebus
, dev_name(dev
));
2068 dev_err(dev
, "hdac link not found\n");
2072 snd_hdac_ext_bus_link_put(ebus
, hlink
);
2077 static int hdac_hdmi_runtime_resume(struct device
*dev
)
2079 struct hdac_ext_device
*edev
= to_hda_ext_device(dev
);
2080 struct hdac_device
*hdac
= &edev
->hdac
;
2081 struct hdac_bus
*bus
= hdac
->bus
;
2082 struct hdac_ext_bus
*ebus
= hbus_to_ebus(bus
);
2083 struct hdac_ext_link
*hlink
= NULL
;
2086 dev_dbg(dev
, "Enter: %s\n", __func__
);
2088 /* controller may not have been initialized for the first time */
2092 hlink
= snd_hdac_ext_bus_get_link(ebus
, dev_name(dev
));
2094 dev_err(dev
, "hdac link not found\n");
2098 snd_hdac_ext_bus_link_get(ebus
, hlink
);
2100 err
= snd_hdac_display_power(bus
, true);
2102 dev_err(bus
->dev
, "Cannot turn on display power on i915\n");
2106 hdac_hdmi_skl_enable_all_pins(&edev
->hdac
);
2107 hdac_hdmi_skl_enable_dp12(&edev
->hdac
);
2110 snd_hdac_codec_read(hdac
, hdac
->afg
, 0, AC_VERB_SET_POWER_STATE
,
2116 #define hdac_hdmi_runtime_suspend NULL
2117 #define hdac_hdmi_runtime_resume NULL
2120 static const struct dev_pm_ops hdac_hdmi_pm
= {
2121 SET_RUNTIME_PM_OPS(hdac_hdmi_runtime_suspend
, hdac_hdmi_runtime_resume
, NULL
)
2122 .prepare
= hdmi_codec_prepare
,
2123 .complete
= hdmi_codec_complete
,
2126 static const struct hda_device_id hdmi_list
[] = {
2127 HDA_CODEC_EXT_ENTRY(0x80862809, 0x100000, "Skylake HDMI", 0),
2128 HDA_CODEC_EXT_ENTRY(0x8086280a, 0x100000, "Broxton HDMI", 0),
2129 HDA_CODEC_EXT_ENTRY(0x8086280b, 0x100000, "Kabylake HDMI", 0),
2130 HDA_CODEC_EXT_ENTRY(0x8086280d, 0x100000, "Geminilake HDMI", 0),
2134 MODULE_DEVICE_TABLE(hdaudio
, hdmi_list
);
2136 static struct hdac_ext_driver hdmi_driver
= {
2139 .name
= "HDMI HDA Codec",
2140 .pm
= &hdac_hdmi_pm
,
2142 .id_table
= hdmi_list
,
2144 .probe
= hdac_hdmi_dev_probe
,
2145 .remove
= hdac_hdmi_dev_remove
,
2148 static int __init
hdmi_init(void)
2150 return snd_hda_ext_driver_register(&hdmi_driver
);
2153 static void __exit
hdmi_exit(void)
2155 snd_hda_ext_driver_unregister(&hdmi_driver
);
2158 module_init(hdmi_init
);
2159 module_exit(hdmi_exit
);
2161 MODULE_LICENSE("GPL v2");
2162 MODULE_DESCRIPTION("HDMI HD codec");
2163 MODULE_AUTHOR("Samreen Nilofer<samreen.nilofer@intel.com>");
2164 MODULE_AUTHOR("Subhransu S. Prusty<subhransu.s.prusty@intel.com>");