3 * patch_hdmi.c - routines for HDMI/DisplayPort codecs
5 * Copyright(c) 2008-2010 Intel Corporation. All rights reserved.
6 * Copyright (c) 2006 ATI Technologies Inc.
7 * Copyright (c) 2008 NVIDIA Corp. All rights reserved.
8 * Copyright (c) 2008 Wei Ni <wni@nvidia.com>
11 * Wu Fengguang <wfg@linux.intel.com>
14 * Wu Fengguang <wfg@linux.intel.com>
16 * This program is free software; you can redistribute it and/or modify it
17 * under the terms of the GNU General Public License as published by the Free
18 * Software Foundation; either version 2 of the License, or (at your option)
21 * This program is distributed in the hope that it will be useful, but
22 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
23 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software Foundation,
28 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
31 #include <linux/init.h>
32 #include <linux/delay.h>
33 #include <linux/slab.h>
34 #include <linux/module.h>
35 #include <sound/core.h>
36 #include <sound/jack.h>
37 #include "hda_codec.h"
38 #include "hda_local.h"
40 static bool static_hdmi_pcm
;
41 module_param(static_hdmi_pcm
, bool, 0644);
42 MODULE_PARM_DESC(static_hdmi_pcm
, "Don't restrict PCM parameters per ELD info");
45 * The HDMI/DisplayPort configuration can be highly dynamic. A graphics device
46 * could support N independent pipes, each of them can be connected to one or
47 * more ports (DVI, HDMI or DisplayPort).
49 * The HDA correspondence of pipes/ports are converter/pin nodes.
51 #define MAX_HDMI_CVTS 4
52 #define MAX_HDMI_PINS 4
54 struct hdmi_spec_per_cvt
{
57 unsigned int channels_min
;
58 unsigned int channels_max
;
64 struct hdmi_spec_per_pin
{
67 hda_nid_t mux_nids
[HDA_MAX_CONNECTIONS
];
69 struct hda_codec
*codec
;
70 struct hdmi_eld sink_eld
;
71 struct delayed_work work
;
76 struct hdmi_spec_per_cvt cvts
[MAX_HDMI_CVTS
];
79 struct hdmi_spec_per_pin pins
[MAX_HDMI_PINS
];
80 struct hda_pcm pcm_rec
[MAX_HDMI_PINS
];
83 * Non-generic ATI/NVIDIA specific
85 struct hda_multi_out multiout
;
86 const struct hda_pcm_stream
*pcm_playback
;
90 struct hdmi_audio_infoframe
{
97 u8 CC02_CT47
; /* CC in bits 0:2, CT in 4:7 */
101 u8 LFEPBL01_LSV36_DM_INH7
;
104 struct dp_audio_infoframe
{
107 u8 ver
; /* 0x11 << 2 */
109 u8 CC02_CT47
; /* match with HDMI infoframe from this on */
113 u8 LFEPBL01_LSV36_DM_INH7
;
116 union audio_infoframe
{
117 struct hdmi_audio_infoframe hdmi
;
118 struct dp_audio_infoframe dp
;
123 * CEA speaker placement:
126 * FLW FL FLC FC FRC FR FRW
133 * The Left/Right Surround channel _notions_ LS/RS in SMPTE 320M corresponds to
134 * CEA RL/RR; The SMPTE channel _assignment_ C/LFE is swapped to CEA LFE/FC.
136 enum cea_speaker_placement
{
137 FL
= (1 << 0), /* Front Left */
138 FC
= (1 << 1), /* Front Center */
139 FR
= (1 << 2), /* Front Right */
140 FLC
= (1 << 3), /* Front Left Center */
141 FRC
= (1 << 4), /* Front Right Center */
142 RL
= (1 << 5), /* Rear Left */
143 RC
= (1 << 6), /* Rear Center */
144 RR
= (1 << 7), /* Rear Right */
145 RLC
= (1 << 8), /* Rear Left Center */
146 RRC
= (1 << 9), /* Rear Right Center */
147 LFE
= (1 << 10), /* Low Frequency Effect */
148 FLW
= (1 << 11), /* Front Left Wide */
149 FRW
= (1 << 12), /* Front Right Wide */
150 FLH
= (1 << 13), /* Front Left High */
151 FCH
= (1 << 14), /* Front Center High */
152 FRH
= (1 << 15), /* Front Right High */
153 TC
= (1 << 16), /* Top Center */
157 * ELD SA bits in the CEA Speaker Allocation data block
159 static int eld_speaker_allocation_bits
[] = {
167 /* the following are not defined in ELD yet */
174 struct cea_channel_speaker_allocation
{
178 /* derived values, just for convenience */
186 * surround40 surround41 surround50 surround51 surround71
187 * ch0 front left = = = =
188 * ch1 front right = = = =
189 * ch2 rear left = = = =
190 * ch3 rear right = = = =
191 * ch4 LFE center center center
196 * surround71 = {FL, FR, RLC, RRC, FC, LFE, RL, RR}
198 static int hdmi_channel_mapping
[0x32][8] = {
200 [0x00] = { 0x00, 0x11, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
202 [0x01] = { 0x00, 0x11, 0x22, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
204 [0x02] = { 0x00, 0x11, 0x23, 0xf2, 0xf4, 0xf5, 0xf6, 0xf7 },
206 [0x08] = { 0x00, 0x11, 0x24, 0x35, 0xf3, 0xf2, 0xf6, 0xf7 },
208 [0x03] = { 0x00, 0x11, 0x23, 0x32, 0x44, 0xf5, 0xf6, 0xf7 },
210 [0x09] = { 0x00, 0x11, 0x24, 0x35, 0x42, 0xf3, 0xf6, 0xf7 },
212 [0x0a] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0xf2, 0xf6, 0xf7 },
214 [0x0b] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0x52, 0xf6, 0xf7 },
216 [0x13] = { 0x00, 0x11, 0x26, 0x37, 0x43, 0x52, 0x64, 0x75 },
220 * This is an ordered list!
222 * The preceding ones have better chances to be selected by
223 * hdmi_channel_allocation().
225 static struct cea_channel_speaker_allocation channel_allocations
[] = {
226 /* channel: 7 6 5 4 3 2 1 0 */
227 { .ca_index
= 0x00, .speakers
= { 0, 0, 0, 0, 0, 0, FR
, FL
} },
229 { .ca_index
= 0x01, .speakers
= { 0, 0, 0, 0, 0, LFE
, FR
, FL
} },
231 { .ca_index
= 0x02, .speakers
= { 0, 0, 0, 0, FC
, 0, FR
, FL
} },
233 { .ca_index
= 0x08, .speakers
= { 0, 0, RR
, RL
, 0, 0, FR
, FL
} },
235 { .ca_index
= 0x09, .speakers
= { 0, 0, RR
, RL
, 0, LFE
, FR
, FL
} },
237 { .ca_index
= 0x0a, .speakers
= { 0, 0, RR
, RL
, FC
, 0, FR
, FL
} },
239 { .ca_index
= 0x0b, .speakers
= { 0, 0, RR
, RL
, FC
, LFE
, FR
, FL
} },
241 { .ca_index
= 0x0f, .speakers
= { 0, RC
, RR
, RL
, FC
, LFE
, FR
, FL
} },
243 { .ca_index
= 0x13, .speakers
= { RRC
, RLC
, RR
, RL
, FC
, LFE
, FR
, FL
} },
245 { .ca_index
= 0x03, .speakers
= { 0, 0, 0, 0, FC
, LFE
, FR
, FL
} },
246 { .ca_index
= 0x04, .speakers
= { 0, 0, 0, RC
, 0, 0, FR
, FL
} },
247 { .ca_index
= 0x05, .speakers
= { 0, 0, 0, RC
, 0, LFE
, FR
, FL
} },
248 { .ca_index
= 0x06, .speakers
= { 0, 0, 0, RC
, FC
, 0, FR
, FL
} },
249 { .ca_index
= 0x07, .speakers
= { 0, 0, 0, RC
, FC
, LFE
, FR
, FL
} },
250 { .ca_index
= 0x0c, .speakers
= { 0, RC
, RR
, RL
, 0, 0, FR
, FL
} },
251 { .ca_index
= 0x0d, .speakers
= { 0, RC
, RR
, RL
, 0, LFE
, FR
, FL
} },
252 { .ca_index
= 0x0e, .speakers
= { 0, RC
, RR
, RL
, FC
, 0, FR
, FL
} },
253 { .ca_index
= 0x10, .speakers
= { RRC
, RLC
, RR
, RL
, 0, 0, FR
, FL
} },
254 { .ca_index
= 0x11, .speakers
= { RRC
, RLC
, RR
, RL
, 0, LFE
, FR
, FL
} },
255 { .ca_index
= 0x12, .speakers
= { RRC
, RLC
, RR
, RL
, FC
, 0, FR
, FL
} },
256 { .ca_index
= 0x14, .speakers
= { FRC
, FLC
, 0, 0, 0, 0, FR
, FL
} },
257 { .ca_index
= 0x15, .speakers
= { FRC
, FLC
, 0, 0, 0, LFE
, FR
, FL
} },
258 { .ca_index
= 0x16, .speakers
= { FRC
, FLC
, 0, 0, FC
, 0, FR
, FL
} },
259 { .ca_index
= 0x17, .speakers
= { FRC
, FLC
, 0, 0, FC
, LFE
, FR
, FL
} },
260 { .ca_index
= 0x18, .speakers
= { FRC
, FLC
, 0, RC
, 0, 0, FR
, FL
} },
261 { .ca_index
= 0x19, .speakers
= { FRC
, FLC
, 0, RC
, 0, LFE
, FR
, FL
} },
262 { .ca_index
= 0x1a, .speakers
= { FRC
, FLC
, 0, RC
, FC
, 0, FR
, FL
} },
263 { .ca_index
= 0x1b, .speakers
= { FRC
, FLC
, 0, RC
, FC
, LFE
, FR
, FL
} },
264 { .ca_index
= 0x1c, .speakers
= { FRC
, FLC
, RR
, RL
, 0, 0, FR
, FL
} },
265 { .ca_index
= 0x1d, .speakers
= { FRC
, FLC
, RR
, RL
, 0, LFE
, FR
, FL
} },
266 { .ca_index
= 0x1e, .speakers
= { FRC
, FLC
, RR
, RL
, FC
, 0, FR
, FL
} },
267 { .ca_index
= 0x1f, .speakers
= { FRC
, FLC
, RR
, RL
, FC
, LFE
, FR
, FL
} },
268 { .ca_index
= 0x20, .speakers
= { 0, FCH
, RR
, RL
, FC
, 0, FR
, FL
} },
269 { .ca_index
= 0x21, .speakers
= { 0, FCH
, RR
, RL
, FC
, LFE
, FR
, FL
} },
270 { .ca_index
= 0x22, .speakers
= { TC
, 0, RR
, RL
, FC
, 0, FR
, FL
} },
271 { .ca_index
= 0x23, .speakers
= { TC
, 0, RR
, RL
, FC
, LFE
, FR
, FL
} },
272 { .ca_index
= 0x24, .speakers
= { FRH
, FLH
, RR
, RL
, 0, 0, FR
, FL
} },
273 { .ca_index
= 0x25, .speakers
= { FRH
, FLH
, RR
, RL
, 0, LFE
, FR
, FL
} },
274 { .ca_index
= 0x26, .speakers
= { FRW
, FLW
, RR
, RL
, 0, 0, FR
, FL
} },
275 { .ca_index
= 0x27, .speakers
= { FRW
, FLW
, RR
, RL
, 0, LFE
, FR
, FL
} },
276 { .ca_index
= 0x28, .speakers
= { TC
, RC
, RR
, RL
, FC
, 0, FR
, FL
} },
277 { .ca_index
= 0x29, .speakers
= { TC
, RC
, RR
, RL
, FC
, LFE
, FR
, FL
} },
278 { .ca_index
= 0x2a, .speakers
= { FCH
, RC
, RR
, RL
, FC
, 0, FR
, FL
} },
279 { .ca_index
= 0x2b, .speakers
= { FCH
, RC
, RR
, RL
, FC
, LFE
, FR
, FL
} },
280 { .ca_index
= 0x2c, .speakers
= { TC
, FCH
, RR
, RL
, FC
, 0, FR
, FL
} },
281 { .ca_index
= 0x2d, .speakers
= { TC
, FCH
, RR
, RL
, FC
, LFE
, FR
, FL
} },
282 { .ca_index
= 0x2e, .speakers
= { FRH
, FLH
, RR
, RL
, FC
, 0, FR
, FL
} },
283 { .ca_index
= 0x2f, .speakers
= { FRH
, FLH
, RR
, RL
, FC
, LFE
, FR
, FL
} },
284 { .ca_index
= 0x30, .speakers
= { FRW
, FLW
, RR
, RL
, FC
, 0, FR
, FL
} },
285 { .ca_index
= 0x31, .speakers
= { FRW
, FLW
, RR
, RL
, FC
, LFE
, FR
, FL
} },
293 static int pin_nid_to_pin_index(struct hdmi_spec
*spec
, hda_nid_t pin_nid
)
297 for (pin_idx
= 0; pin_idx
< spec
->num_pins
; pin_idx
++)
298 if (spec
->pins
[pin_idx
].pin_nid
== pin_nid
)
301 snd_printk(KERN_WARNING
"HDMI: pin nid %d not registered\n", pin_nid
);
305 static int hinfo_to_pin_index(struct hdmi_spec
*spec
,
306 struct hda_pcm_stream
*hinfo
)
310 for (pin_idx
= 0; pin_idx
< spec
->num_pins
; pin_idx
++)
311 if (&spec
->pcm_rec
[pin_idx
].stream
[0] == hinfo
)
314 snd_printk(KERN_WARNING
"HDMI: hinfo %p not registered\n", hinfo
);
318 static int cvt_nid_to_cvt_index(struct hdmi_spec
*spec
, hda_nid_t cvt_nid
)
322 for (cvt_idx
= 0; cvt_idx
< spec
->num_cvts
; cvt_idx
++)
323 if (spec
->cvts
[cvt_idx
].cvt_nid
== cvt_nid
)
326 snd_printk(KERN_WARNING
"HDMI: cvt nid %d not registered\n", cvt_nid
);
330 static int hdmi_eld_ctl_info(struct snd_kcontrol
*kcontrol
,
331 struct snd_ctl_elem_info
*uinfo
)
333 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
334 struct hdmi_spec
*spec
;
338 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BYTES
;
340 pin_idx
= kcontrol
->private_value
;
341 uinfo
->count
= spec
->pins
[pin_idx
].sink_eld
.eld_size
;
346 static int hdmi_eld_ctl_get(struct snd_kcontrol
*kcontrol
,
347 struct snd_ctl_elem_value
*ucontrol
)
349 struct hda_codec
*codec
= snd_kcontrol_chip(kcontrol
);
350 struct hdmi_spec
*spec
;
354 pin_idx
= kcontrol
->private_value
;
356 memcpy(ucontrol
->value
.bytes
.data
,
357 spec
->pins
[pin_idx
].sink_eld
.eld_buffer
, ELD_MAX_SIZE
);
362 static struct snd_kcontrol_new eld_bytes_ctl
= {
363 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
364 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
366 .info
= hdmi_eld_ctl_info
,
367 .get
= hdmi_eld_ctl_get
,
370 static int hdmi_create_eld_ctl(struct hda_codec
*codec
, int pin_idx
,
373 struct snd_kcontrol
*kctl
;
374 struct hdmi_spec
*spec
= codec
->spec
;
377 kctl
= snd_ctl_new1(&eld_bytes_ctl
, codec
);
380 kctl
->private_value
= pin_idx
;
381 kctl
->id
.device
= device
;
383 err
= snd_hda_ctl_add(codec
, spec
->pins
[pin_idx
].pin_nid
, kctl
);
391 static void hdmi_get_dip_index(struct hda_codec
*codec
, hda_nid_t pin_nid
,
392 int *packet_index
, int *byte_index
)
396 val
= snd_hda_codec_read(codec
, pin_nid
, 0,
397 AC_VERB_GET_HDMI_DIP_INDEX
, 0);
399 *packet_index
= val
>> 5;
400 *byte_index
= val
& 0x1f;
404 static void hdmi_set_dip_index(struct hda_codec
*codec
, hda_nid_t pin_nid
,
405 int packet_index
, int byte_index
)
409 val
= (packet_index
<< 5) | (byte_index
& 0x1f);
411 snd_hda_codec_write(codec
, pin_nid
, 0, AC_VERB_SET_HDMI_DIP_INDEX
, val
);
414 static void hdmi_write_dip_byte(struct hda_codec
*codec
, hda_nid_t pin_nid
,
417 snd_hda_codec_write(codec
, pin_nid
, 0, AC_VERB_SET_HDMI_DIP_DATA
, val
);
420 static void hdmi_init_pin(struct hda_codec
*codec
, hda_nid_t pin_nid
)
423 if (get_wcaps(codec
, pin_nid
) & AC_WCAP_OUT_AMP
)
424 snd_hda_codec_write(codec
, pin_nid
, 0,
425 AC_VERB_SET_AMP_GAIN_MUTE
, AMP_OUT_UNMUTE
);
426 /* Disable pin out until stream is active*/
427 snd_hda_codec_write(codec
, pin_nid
, 0,
428 AC_VERB_SET_PIN_WIDGET_CONTROL
, 0);
431 static int hdmi_get_channel_count(struct hda_codec
*codec
, hda_nid_t cvt_nid
)
433 return 1 + snd_hda_codec_read(codec
, cvt_nid
, 0,
434 AC_VERB_GET_CVT_CHAN_COUNT
, 0);
437 static void hdmi_set_channel_count(struct hda_codec
*codec
,
438 hda_nid_t cvt_nid
, int chs
)
440 if (chs
!= hdmi_get_channel_count(codec
, cvt_nid
))
441 snd_hda_codec_write(codec
, cvt_nid
, 0,
442 AC_VERB_SET_CVT_CHAN_COUNT
, chs
- 1);
447 * Channel mapping routines
451 * Compute derived values in channel_allocations[].
453 static void init_channel_allocations(void)
456 struct cea_channel_speaker_allocation
*p
;
458 for (i
= 0; i
< ARRAY_SIZE(channel_allocations
); i
++) {
459 p
= channel_allocations
+ i
;
462 for (j
= 0; j
< ARRAY_SIZE(p
->speakers
); j
++)
463 if (p
->speakers
[j
]) {
465 p
->spk_mask
|= p
->speakers
[j
];
471 * The transformation takes two steps:
473 * eld->spk_alloc => (eld_speaker_allocation_bits[]) => spk_mask
474 * spk_mask => (channel_allocations[]) => ai->CA
476 * TODO: it could select the wrong CA from multiple candidates.
478 static int hdmi_channel_allocation(struct hdmi_eld
*eld
, int channels
)
483 char buf
[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE
];
486 * CA defaults to 0 for basic stereo audio
492 * expand ELD's speaker allocation mask
494 * ELD tells the speaker mask in a compact(paired) form,
495 * expand ELD's notions to match the ones used by Audio InfoFrame.
497 for (i
= 0; i
< ARRAY_SIZE(eld_speaker_allocation_bits
); i
++) {
498 if (eld
->spk_alloc
& (1 << i
))
499 spk_mask
|= eld_speaker_allocation_bits
[i
];
502 /* search for the first working match in the CA table */
503 for (i
= 0; i
< ARRAY_SIZE(channel_allocations
); i
++) {
504 if (channels
== channel_allocations
[i
].channels
&&
505 (spk_mask
& channel_allocations
[i
].spk_mask
) ==
506 channel_allocations
[i
].spk_mask
) {
507 ca
= channel_allocations
[i
].ca_index
;
512 snd_print_channel_allocation(eld
->spk_alloc
, buf
, sizeof(buf
));
513 snd_printdd("HDMI: select CA 0x%x for %d-channel allocation: %s\n",
519 static void hdmi_debug_channel_mapping(struct hda_codec
*codec
,
522 #ifdef CONFIG_SND_DEBUG_VERBOSE
526 for (i
= 0; i
< 8; i
++) {
527 slot
= snd_hda_codec_read(codec
, pin_nid
, 0,
528 AC_VERB_GET_HDMI_CHAN_SLOT
, i
);
529 printk(KERN_DEBUG
"HDMI: ASP channel %d => slot %d\n",
530 slot
>> 4, slot
& 0xf);
536 static void hdmi_setup_channel_mapping(struct hda_codec
*codec
,
543 if (hdmi_channel_mapping
[ca
][1] == 0) {
544 for (i
= 0; i
< channel_allocations
[ca
].channels
; i
++)
545 hdmi_channel_mapping
[ca
][i
] = i
| (i
<< 4);
547 hdmi_channel_mapping
[ca
][i
] = 0xf | (i
<< 4);
550 for (i
= 0; i
< 8; i
++) {
551 err
= snd_hda_codec_write(codec
, pin_nid
, 0,
552 AC_VERB_SET_HDMI_CHAN_SLOT
,
553 hdmi_channel_mapping
[ca
][i
]);
555 snd_printdd(KERN_NOTICE
556 "HDMI: channel mapping failed\n");
561 hdmi_debug_channel_mapping(codec
, pin_nid
);
566 * Audio InfoFrame routines
570 * Enable Audio InfoFrame Transmission
572 static void hdmi_start_infoframe_trans(struct hda_codec
*codec
,
575 hdmi_set_dip_index(codec
, pin_nid
, 0x0, 0x0);
576 snd_hda_codec_write(codec
, pin_nid
, 0, AC_VERB_SET_HDMI_DIP_XMIT
,
581 * Disable Audio InfoFrame Transmission
583 static void hdmi_stop_infoframe_trans(struct hda_codec
*codec
,
586 hdmi_set_dip_index(codec
, pin_nid
, 0x0, 0x0);
587 snd_hda_codec_write(codec
, pin_nid
, 0, AC_VERB_SET_HDMI_DIP_XMIT
,
591 static void hdmi_debug_dip_size(struct hda_codec
*codec
, hda_nid_t pin_nid
)
593 #ifdef CONFIG_SND_DEBUG_VERBOSE
597 size
= snd_hdmi_get_eld_size(codec
, pin_nid
);
598 printk(KERN_DEBUG
"HDMI: ELD buf size is %d\n", size
);
600 for (i
= 0; i
< 8; i
++) {
601 size
= snd_hda_codec_read(codec
, pin_nid
, 0,
602 AC_VERB_GET_HDMI_DIP_SIZE
, i
);
603 printk(KERN_DEBUG
"HDMI: DIP GP[%d] buf size is %d\n", i
, size
);
608 static void hdmi_clear_dip_buffers(struct hda_codec
*codec
, hda_nid_t pin_nid
)
614 for (i
= 0; i
< 8; i
++) {
615 size
= snd_hda_codec_read(codec
, pin_nid
, 0,
616 AC_VERB_GET_HDMI_DIP_SIZE
, i
);
620 hdmi_set_dip_index(codec
, pin_nid
, i
, 0x0);
621 for (j
= 1; j
< 1000; j
++) {
622 hdmi_write_dip_byte(codec
, pin_nid
, 0x0);
623 hdmi_get_dip_index(codec
, pin_nid
, &pi
, &bi
);
625 snd_printd(KERN_INFO
"dip index %d: %d != %d\n",
627 if (bi
== 0) /* byte index wrapped around */
631 "HDMI: DIP GP[%d] buf reported size=%d, written=%d\n",
637 static void hdmi_checksum_audio_infoframe(struct hdmi_audio_infoframe
*hdmi_ai
)
639 u8
*bytes
= (u8
*)hdmi_ai
;
643 hdmi_ai
->checksum
= 0;
645 for (i
= 0; i
< sizeof(*hdmi_ai
); i
++)
648 hdmi_ai
->checksum
= -sum
;
651 static void hdmi_fill_audio_infoframe(struct hda_codec
*codec
,
657 hdmi_debug_dip_size(codec
, pin_nid
);
658 hdmi_clear_dip_buffers(codec
, pin_nid
); /* be paranoid */
660 hdmi_set_dip_index(codec
, pin_nid
, 0x0, 0x0);
661 for (i
= 0; i
< size
; i
++)
662 hdmi_write_dip_byte(codec
, pin_nid
, dip
[i
]);
665 static bool hdmi_infoframe_uptodate(struct hda_codec
*codec
, hda_nid_t pin_nid
,
671 if (snd_hda_codec_read(codec
, pin_nid
, 0, AC_VERB_GET_HDMI_DIP_XMIT
, 0)
675 hdmi_set_dip_index(codec
, pin_nid
, 0x0, 0x0);
676 for (i
= 0; i
< size
; i
++) {
677 val
= snd_hda_codec_read(codec
, pin_nid
, 0,
678 AC_VERB_GET_HDMI_DIP_DATA
, 0);
686 static void hdmi_setup_audio_infoframe(struct hda_codec
*codec
, int pin_idx
,
687 struct snd_pcm_substream
*substream
)
689 struct hdmi_spec
*spec
= codec
->spec
;
690 struct hdmi_spec_per_pin
*per_pin
= &spec
->pins
[pin_idx
];
691 hda_nid_t pin_nid
= per_pin
->pin_nid
;
692 int channels
= substream
->runtime
->channels
;
693 struct hdmi_eld
*eld
;
695 union audio_infoframe ai
;
697 eld
= &spec
->pins
[pin_idx
].sink_eld
;
698 if (!eld
->monitor_present
)
701 ca
= hdmi_channel_allocation(eld
, channels
);
703 memset(&ai
, 0, sizeof(ai
));
704 if (eld
->conn_type
== 0) { /* HDMI */
705 struct hdmi_audio_infoframe
*hdmi_ai
= &ai
.hdmi
;
707 hdmi_ai
->type
= 0x84;
710 hdmi_ai
->CC02_CT47
= channels
- 1;
712 hdmi_checksum_audio_infoframe(hdmi_ai
);
713 } else if (eld
->conn_type
== 1) { /* DisplayPort */
714 struct dp_audio_infoframe
*dp_ai
= &ai
.dp
;
718 dp_ai
->ver
= 0x11 << 2;
719 dp_ai
->CC02_CT47
= channels
- 1;
722 snd_printd("HDMI: unknown connection type at pin %d\n",
728 * sizeof(ai) is used instead of sizeof(*hdmi_ai) or
729 * sizeof(*dp_ai) to avoid partial match/update problems when
730 * the user switches between HDMI/DP monitors.
732 if (!hdmi_infoframe_uptodate(codec
, pin_nid
, ai
.bytes
,
734 snd_printdd("hdmi_setup_audio_infoframe: "
735 "pin=%d channels=%d\n",
738 hdmi_setup_channel_mapping(codec
, pin_nid
, ca
);
739 hdmi_stop_infoframe_trans(codec
, pin_nid
);
740 hdmi_fill_audio_infoframe(codec
, pin_nid
,
741 ai
.bytes
, sizeof(ai
));
742 hdmi_start_infoframe_trans(codec
, pin_nid
);
751 static void hdmi_present_sense(struct hdmi_spec_per_pin
*per_pin
, bool retry
);
753 static void hdmi_intrinsic_event(struct hda_codec
*codec
, unsigned int res
)
755 struct hdmi_spec
*spec
= codec
->spec
;
756 int pin_nid
= res
>> AC_UNSOL_RES_TAG_SHIFT
;
757 int pd
= !!(res
& AC_UNSOL_RES_PD
);
758 int eldv
= !!(res
& AC_UNSOL_RES_ELDV
);
762 "HDMI hot plug event: Codec=%d Pin=%d Presence_Detect=%d ELD_Valid=%d\n",
763 codec
->addr
, pin_nid
, pd
, eldv
);
765 pin_idx
= pin_nid_to_pin_index(spec
, pin_nid
);
769 hdmi_present_sense(&spec
->pins
[pin_idx
], true);
772 static void hdmi_non_intrinsic_event(struct hda_codec
*codec
, unsigned int res
)
774 int tag
= res
>> AC_UNSOL_RES_TAG_SHIFT
;
775 int subtag
= (res
& AC_UNSOL_RES_SUBTAG
) >> AC_UNSOL_RES_SUBTAG_SHIFT
;
776 int cp_state
= !!(res
& AC_UNSOL_RES_CP_STATE
);
777 int cp_ready
= !!(res
& AC_UNSOL_RES_CP_READY
);
780 "HDMI CP event: CODEC=%d PIN=%d SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n",
795 static void hdmi_unsol_event(struct hda_codec
*codec
, unsigned int res
)
797 struct hdmi_spec
*spec
= codec
->spec
;
798 int tag
= res
>> AC_UNSOL_RES_TAG_SHIFT
;
799 int subtag
= (res
& AC_UNSOL_RES_SUBTAG
) >> AC_UNSOL_RES_SUBTAG_SHIFT
;
801 if (pin_nid_to_pin_index(spec
, tag
) < 0) {
802 snd_printd(KERN_INFO
"Unexpected HDMI event tag 0x%x\n", tag
);
807 hdmi_intrinsic_event(codec
, res
);
809 hdmi_non_intrinsic_event(codec
, res
);
816 /* HBR should be Non-PCM, 8 channels */
817 #define is_hbr_format(format) \
818 ((format & AC_FMT_TYPE_NON_PCM) && (format & AC_FMT_CHAN_MASK) == 7)
820 static int hdmi_setup_stream(struct hda_codec
*codec
, hda_nid_t cvt_nid
,
821 hda_nid_t pin_nid
, u32 stream_tag
, int format
)
826 if (snd_hda_query_pin_caps(codec
, pin_nid
) & AC_PINCAP_HBR
) {
827 pinctl
= snd_hda_codec_read(codec
, pin_nid
, 0,
828 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
830 new_pinctl
= pinctl
& ~AC_PINCTL_EPT
;
831 if (is_hbr_format(format
))
832 new_pinctl
|= AC_PINCTL_EPT_HBR
;
834 new_pinctl
|= AC_PINCTL_EPT_NATIVE
;
836 snd_printdd("hdmi_setup_stream: "
837 "NID=0x%x, %spinctl=0x%x\n",
839 pinctl
== new_pinctl
? "" : "new-",
842 if (pinctl
!= new_pinctl
)
843 snd_hda_codec_write(codec
, pin_nid
, 0,
844 AC_VERB_SET_PIN_WIDGET_CONTROL
,
848 if (is_hbr_format(format
) && !new_pinctl
) {
849 snd_printdd("hdmi_setup_stream: HBR is not supported\n");
853 snd_hda_codec_setup_stream(codec
, cvt_nid
, stream_tag
, 0, format
);
860 static int hdmi_pcm_open(struct hda_pcm_stream
*hinfo
,
861 struct hda_codec
*codec
,
862 struct snd_pcm_substream
*substream
)
864 struct hdmi_spec
*spec
= codec
->spec
;
865 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
866 int pin_idx
, cvt_idx
, mux_idx
= 0;
867 struct hdmi_spec_per_pin
*per_pin
;
868 struct hdmi_eld
*eld
;
869 struct hdmi_spec_per_cvt
*per_cvt
= NULL
;
873 pin_idx
= hinfo_to_pin_index(spec
, hinfo
);
874 if (snd_BUG_ON(pin_idx
< 0))
876 per_pin
= &spec
->pins
[pin_idx
];
877 eld
= &per_pin
->sink_eld
;
879 /* Dynamically assign converter to stream */
880 for (cvt_idx
= 0; cvt_idx
< spec
->num_cvts
; cvt_idx
++) {
881 per_cvt
= &spec
->cvts
[cvt_idx
];
883 /* Must not already be assigned */
884 if (per_cvt
->assigned
)
886 /* Must be in pin's mux's list of converters */
887 for (mux_idx
= 0; mux_idx
< per_pin
->num_mux_nids
; mux_idx
++)
888 if (per_pin
->mux_nids
[mux_idx
] == per_cvt
->cvt_nid
)
890 /* Not in mux list */
891 if (mux_idx
== per_pin
->num_mux_nids
)
895 /* No free converters */
896 if (cvt_idx
== spec
->num_cvts
)
899 /* Claim converter */
900 per_cvt
->assigned
= 1;
901 hinfo
->nid
= per_cvt
->cvt_nid
;
903 snd_hda_codec_write(codec
, per_pin
->pin_nid
, 0,
904 AC_VERB_SET_CONNECT_SEL
,
906 pinctl
= snd_hda_codec_read(codec
, per_pin
->pin_nid
, 0,
907 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
908 snd_hda_codec_write(codec
, per_pin
->pin_nid
, 0,
909 AC_VERB_SET_PIN_WIDGET_CONTROL
,
911 snd_hda_spdif_ctls_assign(codec
, pin_idx
, per_cvt
->cvt_nid
);
913 /* Initially set the converter's capabilities */
914 hinfo
->channels_min
= per_cvt
->channels_min
;
915 hinfo
->channels_max
= per_cvt
->channels_max
;
916 hinfo
->rates
= per_cvt
->rates
;
917 hinfo
->formats
= per_cvt
->formats
;
918 hinfo
->maxbps
= per_cvt
->maxbps
;
920 /* Restrict capabilities by ELD if this isn't disabled */
921 if (!static_hdmi_pcm
&& eld
->eld_valid
) {
922 snd_hdmi_eld_update_pcm_info(eld
, hinfo
);
923 if (hinfo
->channels_min
> hinfo
->channels_max
||
924 !hinfo
->rates
|| !hinfo
->formats
)
928 /* Store the updated parameters */
929 runtime
->hw
.channels_min
= hinfo
->channels_min
;
930 runtime
->hw
.channels_max
= hinfo
->channels_max
;
931 runtime
->hw
.formats
= hinfo
->formats
;
932 runtime
->hw
.rates
= hinfo
->rates
;
934 snd_pcm_hw_constraint_step(substream
->runtime
, 0,
935 SNDRV_PCM_HW_PARAM_CHANNELS
, 2);
940 * HDA/HDMI auto parsing
942 static int hdmi_read_pin_conn(struct hda_codec
*codec
, int pin_idx
)
944 struct hdmi_spec
*spec
= codec
->spec
;
945 struct hdmi_spec_per_pin
*per_pin
= &spec
->pins
[pin_idx
];
946 hda_nid_t pin_nid
= per_pin
->pin_nid
;
948 if (!(get_wcaps(codec
, pin_nid
) & AC_WCAP_CONN_LIST
)) {
949 snd_printk(KERN_WARNING
950 "HDMI: pin %d wcaps %#x "
951 "does not support connection list\n",
952 pin_nid
, get_wcaps(codec
, pin_nid
));
956 per_pin
->num_mux_nids
= snd_hda_get_connections(codec
, pin_nid
,
958 HDA_MAX_CONNECTIONS
);
963 static void hdmi_present_sense(struct hdmi_spec_per_pin
*per_pin
, bool retry
)
965 struct hda_codec
*codec
= per_pin
->codec
;
966 struct hdmi_eld
*eld
= &per_pin
->sink_eld
;
967 hda_nid_t pin_nid
= per_pin
->pin_nid
;
969 * Always execute a GetPinSense verb here, even when called from
970 * hdmi_intrinsic_event; for some NVIDIA HW, the unsolicited
971 * response's PD bit is not the real PD value, but indicates that
972 * the real PD value changed. An older version of the HD-audio
973 * specification worked this way. Hence, we just ignore the data in
974 * the unsolicited response to avoid custom WARs.
976 int present
= snd_hda_pin_sense(codec
, pin_nid
);
977 bool eld_valid
= false;
979 memset(eld
, 0, offsetof(struct hdmi_eld
, eld_buffer
));
981 eld
->monitor_present
= !!(present
& AC_PINSENSE_PRESENCE
);
982 if (eld
->monitor_present
)
983 eld_valid
= !!(present
& AC_PINSENSE_ELDV
);
986 "HDMI status: Codec=%d Pin=%d Presence_Detect=%d ELD_Valid=%d\n",
987 codec
->addr
, pin_nid
, eld
->monitor_present
, eld_valid
);
990 if (!snd_hdmi_get_eld(eld
, codec
, pin_nid
))
991 snd_hdmi_show_eld(eld
);
993 queue_delayed_work(codec
->bus
->workq
,
995 msecs_to_jiffies(300));
999 snd_hda_input_jack_report(codec
, pin_nid
);
1002 static void hdmi_repoll_eld(struct work_struct
*work
)
1004 struct hdmi_spec_per_pin
*per_pin
=
1005 container_of(to_delayed_work(work
), struct hdmi_spec_per_pin
, work
);
1007 hdmi_present_sense(per_pin
, false);
1010 static int hdmi_add_pin(struct hda_codec
*codec
, hda_nid_t pin_nid
)
1012 struct hdmi_spec
*spec
= codec
->spec
;
1013 unsigned int caps
, config
;
1015 struct hdmi_spec_per_pin
*per_pin
;
1018 caps
= snd_hda_param_read(codec
, pin_nid
, AC_PAR_PIN_CAP
);
1019 if (!(caps
& (AC_PINCAP_HDMI
| AC_PINCAP_DP
)))
1022 config
= snd_hda_codec_read(codec
, pin_nid
, 0,
1023 AC_VERB_GET_CONFIG_DEFAULT
, 0);
1024 if (get_defcfg_connect(config
) == AC_JACK_PORT_NONE
)
1027 if (snd_BUG_ON(spec
->num_pins
>= MAX_HDMI_PINS
))
1030 pin_idx
= spec
->num_pins
;
1031 per_pin
= &spec
->pins
[pin_idx
];
1033 per_pin
->pin_nid
= pin_nid
;
1035 err
= hdmi_read_pin_conn(codec
, pin_idx
);
1044 static int hdmi_add_cvt(struct hda_codec
*codec
, hda_nid_t cvt_nid
)
1046 struct hdmi_spec
*spec
= codec
->spec
;
1048 struct hdmi_spec_per_cvt
*per_cvt
;
1052 if (snd_BUG_ON(spec
->num_cvts
>= MAX_HDMI_CVTS
))
1055 chans
= get_wcaps(codec
, cvt_nid
);
1056 chans
= get_wcaps_channels(chans
);
1058 cvt_idx
= spec
->num_cvts
;
1059 per_cvt
= &spec
->cvts
[cvt_idx
];
1061 per_cvt
->cvt_nid
= cvt_nid
;
1062 per_cvt
->channels_min
= 2;
1064 per_cvt
->channels_max
= chans
;
1066 err
= snd_hda_query_supported_pcm(codec
, cvt_nid
,
1078 static int hdmi_parse_codec(struct hda_codec
*codec
)
1083 nodes
= snd_hda_get_sub_nodes(codec
, codec
->afg
, &nid
);
1084 if (!nid
|| nodes
< 0) {
1085 snd_printk(KERN_WARNING
"HDMI: failed to get afg sub nodes\n");
1089 for (i
= 0; i
< nodes
; i
++, nid
++) {
1093 caps
= snd_hda_param_read(codec
, nid
, AC_PAR_AUDIO_WIDGET_CAP
);
1094 type
= get_wcaps_type(caps
);
1096 if (!(caps
& AC_WCAP_DIGITAL
))
1100 case AC_WID_AUD_OUT
:
1101 hdmi_add_cvt(codec
, nid
);
1104 hdmi_add_pin(codec
, nid
);
1110 * G45/IbexPeak don't support EPSS: the unsolicited pin hot plug event
1111 * can be lost and presence sense verb will become inaccurate if the
1112 * HDA link is powered off at hot plug or hw initialization time.
1114 #ifdef CONFIG_SND_HDA_POWER_SAVE
1115 if (!(snd_hda_param_read(codec
, codec
->afg
, AC_PAR_POWER_STATE
) &
1117 codec
->bus
->power_keep_link_on
= 1;
1125 static char *generic_hdmi_pcm_names
[MAX_HDMI_PINS
] = {
1136 static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
1137 struct hda_codec
*codec
,
1138 unsigned int stream_tag
,
1139 unsigned int format
,
1140 struct snd_pcm_substream
*substream
)
1142 hda_nid_t cvt_nid
= hinfo
->nid
;
1143 struct hdmi_spec
*spec
= codec
->spec
;
1144 int pin_idx
= hinfo_to_pin_index(spec
, hinfo
);
1145 hda_nid_t pin_nid
= spec
->pins
[pin_idx
].pin_nid
;
1147 hdmi_set_channel_count(codec
, cvt_nid
, substream
->runtime
->channels
);
1149 hdmi_setup_audio_infoframe(codec
, pin_idx
, substream
);
1151 return hdmi_setup_stream(codec
, cvt_nid
, pin_nid
, stream_tag
, format
);
1154 static int generic_hdmi_playback_pcm_cleanup(struct hda_pcm_stream
*hinfo
,
1155 struct hda_codec
*codec
,
1156 struct snd_pcm_substream
*substream
)
1158 struct hdmi_spec
*spec
= codec
->spec
;
1159 int cvt_idx
, pin_idx
;
1160 struct hdmi_spec_per_cvt
*per_cvt
;
1161 struct hdmi_spec_per_pin
*per_pin
;
1164 snd_hda_codec_cleanup_stream(codec
, hinfo
->nid
);
1167 cvt_idx
= cvt_nid_to_cvt_index(spec
, hinfo
->nid
);
1168 if (snd_BUG_ON(cvt_idx
< 0))
1170 per_cvt
= &spec
->cvts
[cvt_idx
];
1172 snd_BUG_ON(!per_cvt
->assigned
);
1173 per_cvt
->assigned
= 0;
1176 pin_idx
= hinfo_to_pin_index(spec
, hinfo
);
1177 if (snd_BUG_ON(pin_idx
< 0))
1179 per_pin
= &spec
->pins
[pin_idx
];
1181 pinctl
= snd_hda_codec_read(codec
, per_pin
->pin_nid
, 0,
1182 AC_VERB_GET_PIN_WIDGET_CONTROL
, 0);
1183 snd_hda_codec_write(codec
, per_pin
->pin_nid
, 0,
1184 AC_VERB_SET_PIN_WIDGET_CONTROL
,
1186 snd_hda_spdif_ctls_unassign(codec
, pin_idx
);
1192 static const struct hda_pcm_ops generic_ops
= {
1193 .open
= hdmi_pcm_open
,
1194 .prepare
= generic_hdmi_playback_pcm_prepare
,
1195 .cleanup
= generic_hdmi_playback_pcm_cleanup
,
1198 static int generic_hdmi_build_pcms(struct hda_codec
*codec
)
1200 struct hdmi_spec
*spec
= codec
->spec
;
1203 for (pin_idx
= 0; pin_idx
< spec
->num_pins
; pin_idx
++) {
1204 struct hda_pcm
*info
;
1205 struct hda_pcm_stream
*pstr
;
1207 info
= &spec
->pcm_rec
[pin_idx
];
1208 info
->name
= generic_hdmi_pcm_names
[pin_idx
];
1209 info
->pcm_type
= HDA_PCM_TYPE_HDMI
;
1211 pstr
= &info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
];
1212 pstr
->substreams
= 1;
1213 pstr
->ops
= generic_ops
;
1214 /* other pstr fields are set in open */
1217 codec
->num_pcms
= spec
->num_pins
;
1218 codec
->pcm_info
= spec
->pcm_rec
;
1223 static int generic_hdmi_build_jack(struct hda_codec
*codec
, int pin_idx
)
1227 struct hdmi_spec
*spec
= codec
->spec
;
1228 struct hdmi_spec_per_pin
*per_pin
= &spec
->pins
[pin_idx
];
1229 int pcmdev
= spec
->pcm_rec
[pin_idx
].device
;
1231 snprintf(hdmi_str
, sizeof(hdmi_str
), "HDMI/DP,pcm=%d", pcmdev
);
1233 err
= snd_hda_input_jack_add(codec
, per_pin
->pin_nid
,
1234 SND_JACK_VIDEOOUT
, pcmdev
> 0 ? hdmi_str
: NULL
);
1238 hdmi_present_sense(per_pin
, false);
1242 static int generic_hdmi_build_controls(struct hda_codec
*codec
)
1244 struct hdmi_spec
*spec
= codec
->spec
;
1248 for (pin_idx
= 0; pin_idx
< spec
->num_pins
; pin_idx
++) {
1249 struct hdmi_spec_per_pin
*per_pin
= &spec
->pins
[pin_idx
];
1251 err
= generic_hdmi_build_jack(codec
, pin_idx
);
1255 err
= snd_hda_create_spdif_out_ctls(codec
,
1257 per_pin
->mux_nids
[0]);
1260 snd_hda_spdif_ctls_unassign(codec
, pin_idx
);
1262 /* add control for ELD Bytes */
1263 err
= hdmi_create_eld_ctl(codec
,
1265 spec
->pcm_rec
[pin_idx
].device
);
1274 static int generic_hdmi_init(struct hda_codec
*codec
)
1276 struct hdmi_spec
*spec
= codec
->spec
;
1279 for (pin_idx
= 0; pin_idx
< spec
->num_pins
; pin_idx
++) {
1280 struct hdmi_spec_per_pin
*per_pin
= &spec
->pins
[pin_idx
];
1281 hda_nid_t pin_nid
= per_pin
->pin_nid
;
1282 struct hdmi_eld
*eld
= &per_pin
->sink_eld
;
1284 hdmi_init_pin(codec
, pin_nid
);
1285 snd_hda_codec_write(codec
, pin_nid
, 0,
1286 AC_VERB_SET_UNSOLICITED_ENABLE
,
1287 AC_USRSP_EN
| pin_nid
);
1289 per_pin
->codec
= codec
;
1290 INIT_DELAYED_WORK(&per_pin
->work
, hdmi_repoll_eld
);
1291 snd_hda_eld_proc_new(codec
, eld
, pin_idx
);
1296 static void generic_hdmi_free(struct hda_codec
*codec
)
1298 struct hdmi_spec
*spec
= codec
->spec
;
1301 for (pin_idx
= 0; pin_idx
< spec
->num_pins
; pin_idx
++) {
1302 struct hdmi_spec_per_pin
*per_pin
= &spec
->pins
[pin_idx
];
1303 struct hdmi_eld
*eld
= &per_pin
->sink_eld
;
1305 cancel_delayed_work(&per_pin
->work
);
1306 snd_hda_eld_proc_free(codec
, eld
);
1308 snd_hda_input_jack_free(codec
);
1310 flush_workqueue(codec
->bus
->workq
);
1314 static const struct hda_codec_ops generic_hdmi_patch_ops
= {
1315 .init
= generic_hdmi_init
,
1316 .free
= generic_hdmi_free
,
1317 .build_pcms
= generic_hdmi_build_pcms
,
1318 .build_controls
= generic_hdmi_build_controls
,
1319 .unsol_event
= hdmi_unsol_event
,
1322 static int patch_generic_hdmi(struct hda_codec
*codec
)
1324 struct hdmi_spec
*spec
;
1326 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
1331 if (hdmi_parse_codec(codec
) < 0) {
1336 codec
->patch_ops
= generic_hdmi_patch_ops
;
1338 init_channel_allocations();
1344 * Shared non-generic implementations
1347 static int simple_playback_build_pcms(struct hda_codec
*codec
)
1349 struct hdmi_spec
*spec
= codec
->spec
;
1350 struct hda_pcm
*info
= spec
->pcm_rec
;
1353 codec
->num_pcms
= spec
->num_cvts
;
1354 codec
->pcm_info
= info
;
1356 for (i
= 0; i
< codec
->num_pcms
; i
++, info
++) {
1358 struct hda_pcm_stream
*pstr
;
1360 chans
= get_wcaps(codec
, spec
->cvts
[i
].cvt_nid
);
1361 chans
= get_wcaps_channels(chans
);
1363 info
->name
= generic_hdmi_pcm_names
[i
];
1364 info
->pcm_type
= HDA_PCM_TYPE_HDMI
;
1365 pstr
= &info
->stream
[SNDRV_PCM_STREAM_PLAYBACK
];
1366 snd_BUG_ON(!spec
->pcm_playback
);
1367 *pstr
= *spec
->pcm_playback
;
1368 pstr
->nid
= spec
->cvts
[i
].cvt_nid
;
1369 if (pstr
->channels_max
<= 2 && chans
&& chans
<= 16)
1370 pstr
->channels_max
= chans
;
1376 static int simple_playback_build_controls(struct hda_codec
*codec
)
1378 struct hdmi_spec
*spec
= codec
->spec
;
1382 for (i
= 0; i
< codec
->num_pcms
; i
++) {
1383 err
= snd_hda_create_spdif_out_ctls(codec
,
1384 spec
->cvts
[i
].cvt_nid
,
1385 spec
->cvts
[i
].cvt_nid
);
1393 static void simple_playback_free(struct hda_codec
*codec
)
1395 struct hdmi_spec
*spec
= codec
->spec
;
1401 * Nvidia specific implementations
1404 #define Nv_VERB_SET_Channel_Allocation 0xF79
1405 #define Nv_VERB_SET_Info_Frame_Checksum 0xF7A
1406 #define Nv_VERB_SET_Audio_Protection_On 0xF98
1407 #define Nv_VERB_SET_Audio_Protection_Off 0xF99
1409 #define nvhdmi_master_con_nid_7x 0x04
1410 #define nvhdmi_master_pin_nid_7x 0x05
1412 static const hda_nid_t nvhdmi_con_nids_7x
[4] = {
1413 /*front, rear, clfe, rear_surr */
1417 static const struct hda_verb nvhdmi_basic_init_7x
[] = {
1418 /* set audio protect on */
1419 { 0x1, Nv_VERB_SET_Audio_Protection_On
, 0x1},
1420 /* enable digital output on pin widget */
1421 { 0x5, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
| 0x5 },
1422 { 0x7, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
| 0x5 },
1423 { 0x9, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
| 0x5 },
1424 { 0xb, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
| 0x5 },
1425 { 0xd, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
| 0x5 },
1429 #ifdef LIMITED_RATE_FMT_SUPPORT
1430 /* support only the safe format and rate */
1431 #define SUPPORTED_RATES SNDRV_PCM_RATE_48000
1432 #define SUPPORTED_MAXBPS 16
1433 #define SUPPORTED_FORMATS SNDRV_PCM_FMTBIT_S16_LE
1435 /* support all rates and formats */
1436 #define SUPPORTED_RATES \
1437 (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\
1438 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |\
1439 SNDRV_PCM_RATE_192000)
1440 #define SUPPORTED_MAXBPS 24
1441 #define SUPPORTED_FORMATS \
1442 (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
1445 static int nvhdmi_7x_init(struct hda_codec
*codec
)
1447 snd_hda_sequence_write(codec
, nvhdmi_basic_init_7x
);
1451 static unsigned int channels_2_6_8
[] = {
1455 static unsigned int channels_2_8
[] = {
1459 static struct snd_pcm_hw_constraint_list hw_constraints_2_6_8_channels
= {
1460 .count
= ARRAY_SIZE(channels_2_6_8
),
1461 .list
= channels_2_6_8
,
1465 static struct snd_pcm_hw_constraint_list hw_constraints_2_8_channels
= {
1466 .count
= ARRAY_SIZE(channels_2_8
),
1467 .list
= channels_2_8
,
1471 static int simple_playback_pcm_open(struct hda_pcm_stream
*hinfo
,
1472 struct hda_codec
*codec
,
1473 struct snd_pcm_substream
*substream
)
1475 struct hdmi_spec
*spec
= codec
->spec
;
1476 struct snd_pcm_hw_constraint_list
*hw_constraints_channels
= NULL
;
1478 switch (codec
->preset
->id
) {
1483 hw_constraints_channels
= &hw_constraints_2_8_channels
;
1486 hw_constraints_channels
= &hw_constraints_2_6_8_channels
;
1492 if (hw_constraints_channels
!= NULL
) {
1493 snd_pcm_hw_constraint_list(substream
->runtime
, 0,
1494 SNDRV_PCM_HW_PARAM_CHANNELS
,
1495 hw_constraints_channels
);
1497 snd_pcm_hw_constraint_step(substream
->runtime
, 0,
1498 SNDRV_PCM_HW_PARAM_CHANNELS
, 2);
1501 return snd_hda_multi_out_dig_open(codec
, &spec
->multiout
);
1504 static int simple_playback_pcm_close(struct hda_pcm_stream
*hinfo
,
1505 struct hda_codec
*codec
,
1506 struct snd_pcm_substream
*substream
)
1508 struct hdmi_spec
*spec
= codec
->spec
;
1509 return snd_hda_multi_out_dig_close(codec
, &spec
->multiout
);
1512 static int simple_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
1513 struct hda_codec
*codec
,
1514 unsigned int stream_tag
,
1515 unsigned int format
,
1516 struct snd_pcm_substream
*substream
)
1518 struct hdmi_spec
*spec
= codec
->spec
;
1519 return snd_hda_multi_out_dig_prepare(codec
, &spec
->multiout
,
1520 stream_tag
, format
, substream
);
1523 static void nvhdmi_8ch_7x_set_info_frame_parameters(struct hda_codec
*codec
,
1526 unsigned int chanmask
;
1527 int chan
= channels
? (channels
- 1) : 1;
1546 /* Set the audio infoframe channel allocation and checksum fields. The
1547 * channel count is computed implicitly by the hardware. */
1548 snd_hda_codec_write(codec
, 0x1, 0,
1549 Nv_VERB_SET_Channel_Allocation
, chanmask
);
1551 snd_hda_codec_write(codec
, 0x1, 0,
1552 Nv_VERB_SET_Info_Frame_Checksum
,
1553 (0x71 - chan
- chanmask
));
1556 static int nvhdmi_8ch_7x_pcm_close(struct hda_pcm_stream
*hinfo
,
1557 struct hda_codec
*codec
,
1558 struct snd_pcm_substream
*substream
)
1560 struct hdmi_spec
*spec
= codec
->spec
;
1563 snd_hda_codec_write(codec
, nvhdmi_master_con_nid_7x
,
1564 0, AC_VERB_SET_CHANNEL_STREAMID
, 0);
1565 for (i
= 0; i
< 4; i
++) {
1566 /* set the stream id */
1567 snd_hda_codec_write(codec
, nvhdmi_con_nids_7x
[i
], 0,
1568 AC_VERB_SET_CHANNEL_STREAMID
, 0);
1569 /* set the stream format */
1570 snd_hda_codec_write(codec
, nvhdmi_con_nids_7x
[i
], 0,
1571 AC_VERB_SET_STREAM_FORMAT
, 0);
1574 /* The audio hardware sends a channel count of 0x7 (8ch) when all the
1575 * streams are disabled. */
1576 nvhdmi_8ch_7x_set_info_frame_parameters(codec
, 8);
1578 return snd_hda_multi_out_dig_close(codec
, &spec
->multiout
);
1581 static int nvhdmi_8ch_7x_pcm_prepare(struct hda_pcm_stream
*hinfo
,
1582 struct hda_codec
*codec
,
1583 unsigned int stream_tag
,
1584 unsigned int format
,
1585 struct snd_pcm_substream
*substream
)
1588 unsigned int dataDCC2
, channel_id
;
1590 struct hdmi_spec
*spec
= codec
->spec
;
1591 struct hda_spdif_out
*spdif
=
1592 snd_hda_spdif_out_of_nid(codec
, spec
->cvts
[0].cvt_nid
);
1594 mutex_lock(&codec
->spdif_mutex
);
1596 chs
= substream
->runtime
->channels
;
1600 /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */
1601 if (codec
->spdif_status_reset
&& (spdif
->ctls
& AC_DIG1_ENABLE
))
1602 snd_hda_codec_write(codec
,
1603 nvhdmi_master_con_nid_7x
,
1605 AC_VERB_SET_DIGI_CONVERT_1
,
1606 spdif
->ctls
& ~AC_DIG1_ENABLE
& 0xff);
1608 /* set the stream id */
1609 snd_hda_codec_write(codec
, nvhdmi_master_con_nid_7x
, 0,
1610 AC_VERB_SET_CHANNEL_STREAMID
, (stream_tag
<< 4) | 0x0);
1612 /* set the stream format */
1613 snd_hda_codec_write(codec
, nvhdmi_master_con_nid_7x
, 0,
1614 AC_VERB_SET_STREAM_FORMAT
, format
);
1616 /* turn on again (if needed) */
1617 /* enable and set the channel status audio/data flag */
1618 if (codec
->spdif_status_reset
&& (spdif
->ctls
& AC_DIG1_ENABLE
)) {
1619 snd_hda_codec_write(codec
,
1620 nvhdmi_master_con_nid_7x
,
1622 AC_VERB_SET_DIGI_CONVERT_1
,
1623 spdif
->ctls
& 0xff);
1624 snd_hda_codec_write(codec
,
1625 nvhdmi_master_con_nid_7x
,
1627 AC_VERB_SET_DIGI_CONVERT_2
, dataDCC2
);
1630 for (i
= 0; i
< 4; i
++) {
1636 /* turn off SPDIF once;
1637 *otherwise the IEC958 bits won't be updated
1639 if (codec
->spdif_status_reset
&&
1640 (spdif
->ctls
& AC_DIG1_ENABLE
))
1641 snd_hda_codec_write(codec
,
1642 nvhdmi_con_nids_7x
[i
],
1644 AC_VERB_SET_DIGI_CONVERT_1
,
1645 spdif
->ctls
& ~AC_DIG1_ENABLE
& 0xff);
1646 /* set the stream id */
1647 snd_hda_codec_write(codec
,
1648 nvhdmi_con_nids_7x
[i
],
1650 AC_VERB_SET_CHANNEL_STREAMID
,
1651 (stream_tag
<< 4) | channel_id
);
1652 /* set the stream format */
1653 snd_hda_codec_write(codec
,
1654 nvhdmi_con_nids_7x
[i
],
1656 AC_VERB_SET_STREAM_FORMAT
,
1658 /* turn on again (if needed) */
1659 /* enable and set the channel status audio/data flag */
1660 if (codec
->spdif_status_reset
&&
1661 (spdif
->ctls
& AC_DIG1_ENABLE
)) {
1662 snd_hda_codec_write(codec
,
1663 nvhdmi_con_nids_7x
[i
],
1665 AC_VERB_SET_DIGI_CONVERT_1
,
1666 spdif
->ctls
& 0xff);
1667 snd_hda_codec_write(codec
,
1668 nvhdmi_con_nids_7x
[i
],
1670 AC_VERB_SET_DIGI_CONVERT_2
, dataDCC2
);
1674 nvhdmi_8ch_7x_set_info_frame_parameters(codec
, chs
);
1676 mutex_unlock(&codec
->spdif_mutex
);
1680 static const struct hda_pcm_stream nvhdmi_pcm_playback_8ch_7x
= {
1684 .nid
= nvhdmi_master_con_nid_7x
,
1685 .rates
= SUPPORTED_RATES
,
1686 .maxbps
= SUPPORTED_MAXBPS
,
1687 .formats
= SUPPORTED_FORMATS
,
1689 .open
= simple_playback_pcm_open
,
1690 .close
= nvhdmi_8ch_7x_pcm_close
,
1691 .prepare
= nvhdmi_8ch_7x_pcm_prepare
1695 static const struct hda_pcm_stream nvhdmi_pcm_playback_2ch
= {
1699 .nid
= nvhdmi_master_con_nid_7x
,
1700 .rates
= SUPPORTED_RATES
,
1701 .maxbps
= SUPPORTED_MAXBPS
,
1702 .formats
= SUPPORTED_FORMATS
,
1704 .open
= simple_playback_pcm_open
,
1705 .close
= simple_playback_pcm_close
,
1706 .prepare
= simple_playback_pcm_prepare
1710 static const struct hda_codec_ops nvhdmi_patch_ops_8ch_7x
= {
1711 .build_controls
= simple_playback_build_controls
,
1712 .build_pcms
= simple_playback_build_pcms
,
1713 .init
= nvhdmi_7x_init
,
1714 .free
= simple_playback_free
,
1717 static const struct hda_codec_ops nvhdmi_patch_ops_2ch
= {
1718 .build_controls
= simple_playback_build_controls
,
1719 .build_pcms
= simple_playback_build_pcms
,
1720 .init
= nvhdmi_7x_init
,
1721 .free
= simple_playback_free
,
1724 static int patch_nvhdmi_2ch(struct hda_codec
*codec
)
1726 struct hdmi_spec
*spec
;
1728 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
1734 spec
->multiout
.num_dacs
= 0; /* no analog */
1735 spec
->multiout
.max_channels
= 2;
1736 spec
->multiout
.dig_out_nid
= nvhdmi_master_con_nid_7x
;
1738 spec
->cvts
[0].cvt_nid
= nvhdmi_master_con_nid_7x
;
1739 spec
->pcm_playback
= &nvhdmi_pcm_playback_2ch
;
1741 codec
->patch_ops
= nvhdmi_patch_ops_2ch
;
1746 static int patch_nvhdmi_8ch_7x(struct hda_codec
*codec
)
1748 struct hdmi_spec
*spec
;
1749 int err
= patch_nvhdmi_2ch(codec
);
1754 spec
->multiout
.max_channels
= 8;
1755 spec
->pcm_playback
= &nvhdmi_pcm_playback_8ch_7x
;
1756 codec
->patch_ops
= nvhdmi_patch_ops_8ch_7x
;
1758 /* Initialize the audio infoframe channel mask and checksum to something
1760 nvhdmi_8ch_7x_set_info_frame_parameters(codec
, 8);
1766 * ATI-specific implementations
1768 * FIXME: we may omit the whole this and use the generic code once after
1769 * it's confirmed to work.
1772 #define ATIHDMI_CVT_NID 0x02 /* audio converter */
1773 #define ATIHDMI_PIN_NID 0x03 /* HDMI output pin */
1775 static int atihdmi_playback_pcm_prepare(struct hda_pcm_stream
*hinfo
,
1776 struct hda_codec
*codec
,
1777 unsigned int stream_tag
,
1778 unsigned int format
,
1779 struct snd_pcm_substream
*substream
)
1781 struct hdmi_spec
*spec
= codec
->spec
;
1782 int chans
= substream
->runtime
->channels
;
1785 err
= simple_playback_pcm_prepare(hinfo
, codec
, stream_tag
, format
,
1789 snd_hda_codec_write(codec
, spec
->cvts
[0].cvt_nid
, 0,
1790 AC_VERB_SET_CVT_CHAN_COUNT
, chans
- 1);
1792 for (i
= 0; i
< chans
; i
++) {
1793 snd_hda_codec_write(codec
, spec
->cvts
[0].cvt_nid
, 0,
1794 AC_VERB_SET_HDMI_CHAN_SLOT
,
1800 static const struct hda_pcm_stream atihdmi_pcm_digital_playback
= {
1804 .nid
= ATIHDMI_CVT_NID
,
1806 .open
= simple_playback_pcm_open
,
1807 .close
= simple_playback_pcm_close
,
1808 .prepare
= atihdmi_playback_pcm_prepare
1812 static const struct hda_verb atihdmi_basic_init
[] = {
1813 /* enable digital output on pin widget */
1814 { 0x03, AC_VERB_SET_PIN_WIDGET_CONTROL
, PIN_OUT
},
1818 static int atihdmi_init(struct hda_codec
*codec
)
1820 struct hdmi_spec
*spec
= codec
->spec
;
1822 snd_hda_sequence_write(codec
, atihdmi_basic_init
);
1823 /* SI codec requires to unmute the pin */
1824 if (get_wcaps(codec
, spec
->pins
[0].pin_nid
) & AC_WCAP_OUT_AMP
)
1825 snd_hda_codec_write(codec
, spec
->pins
[0].pin_nid
, 0,
1826 AC_VERB_SET_AMP_GAIN_MUTE
,
1831 static const struct hda_codec_ops atihdmi_patch_ops
= {
1832 .build_controls
= simple_playback_build_controls
,
1833 .build_pcms
= simple_playback_build_pcms
,
1834 .init
= atihdmi_init
,
1835 .free
= simple_playback_free
,
1839 static int patch_atihdmi(struct hda_codec
*codec
)
1841 struct hdmi_spec
*spec
;
1843 spec
= kzalloc(sizeof(*spec
), GFP_KERNEL
);
1849 spec
->multiout
.num_dacs
= 0; /* no analog */
1850 spec
->multiout
.max_channels
= 2;
1851 spec
->multiout
.dig_out_nid
= ATIHDMI_CVT_NID
;
1853 spec
->cvts
[0].cvt_nid
= ATIHDMI_CVT_NID
;
1854 spec
->pins
[0].pin_nid
= ATIHDMI_PIN_NID
;
1855 spec
->pcm_playback
= &atihdmi_pcm_digital_playback
;
1857 codec
->patch_ops
= atihdmi_patch_ops
;
1866 static const struct hda_codec_preset snd_hda_preset_hdmi
[] = {
1867 { .id
= 0x1002793c, .name
= "RS600 HDMI", .patch
= patch_atihdmi
},
1868 { .id
= 0x10027919, .name
= "RS600 HDMI", .patch
= patch_atihdmi
},
1869 { .id
= 0x1002791a, .name
= "RS690/780 HDMI", .patch
= patch_atihdmi
},
1870 { .id
= 0x1002aa01, .name
= "R6xx HDMI", .patch
= patch_generic_hdmi
},
1871 { .id
= 0x10951390, .name
= "SiI1390 HDMI", .patch
= patch_generic_hdmi
},
1872 { .id
= 0x10951392, .name
= "SiI1392 HDMI", .patch
= patch_generic_hdmi
},
1873 { .id
= 0x17e80047, .name
= "Chrontel HDMI", .patch
= patch_generic_hdmi
},
1874 { .id
= 0x10de0002, .name
= "MCP77/78 HDMI", .patch
= patch_nvhdmi_8ch_7x
},
1875 { .id
= 0x10de0003, .name
= "MCP77/78 HDMI", .patch
= patch_nvhdmi_8ch_7x
},
1876 { .id
= 0x10de0005, .name
= "MCP77/78 HDMI", .patch
= patch_nvhdmi_8ch_7x
},
1877 { .id
= 0x10de0006, .name
= "MCP77/78 HDMI", .patch
= patch_nvhdmi_8ch_7x
},
1878 { .id
= 0x10de0007, .name
= "MCP79/7A HDMI", .patch
= patch_nvhdmi_8ch_7x
},
1879 { .id
= 0x10de000a, .name
= "GPU 0a HDMI/DP", .patch
= patch_generic_hdmi
},
1880 { .id
= 0x10de000b, .name
= "GPU 0b HDMI/DP", .patch
= patch_generic_hdmi
},
1881 { .id
= 0x10de000c, .name
= "MCP89 HDMI", .patch
= patch_generic_hdmi
},
1882 { .id
= 0x10de000d, .name
= "GPU 0d HDMI/DP", .patch
= patch_generic_hdmi
},
1883 { .id
= 0x10de0010, .name
= "GPU 10 HDMI/DP", .patch
= patch_generic_hdmi
},
1884 { .id
= 0x10de0011, .name
= "GPU 11 HDMI/DP", .patch
= patch_generic_hdmi
},
1885 { .id
= 0x10de0012, .name
= "GPU 12 HDMI/DP", .patch
= patch_generic_hdmi
},
1886 { .id
= 0x10de0013, .name
= "GPU 13 HDMI/DP", .patch
= patch_generic_hdmi
},
1887 { .id
= 0x10de0014, .name
= "GPU 14 HDMI/DP", .patch
= patch_generic_hdmi
},
1888 { .id
= 0x10de0015, .name
= "GPU 15 HDMI/DP", .patch
= patch_generic_hdmi
},
1889 { .id
= 0x10de0016, .name
= "GPU 16 HDMI/DP", .patch
= patch_generic_hdmi
},
1890 /* 17 is known to be absent */
1891 { .id
= 0x10de0018, .name
= "GPU 18 HDMI/DP", .patch
= patch_generic_hdmi
},
1892 { .id
= 0x10de0019, .name
= "GPU 19 HDMI/DP", .patch
= patch_generic_hdmi
},
1893 { .id
= 0x10de001a, .name
= "GPU 1a HDMI/DP", .patch
= patch_generic_hdmi
},
1894 { .id
= 0x10de001b, .name
= "GPU 1b HDMI/DP", .patch
= patch_generic_hdmi
},
1895 { .id
= 0x10de001c, .name
= "GPU 1c HDMI/DP", .patch
= patch_generic_hdmi
},
1896 { .id
= 0x10de0040, .name
= "GPU 40 HDMI/DP", .patch
= patch_generic_hdmi
},
1897 { .id
= 0x10de0041, .name
= "GPU 41 HDMI/DP", .patch
= patch_generic_hdmi
},
1898 { .id
= 0x10de0042, .name
= "GPU 42 HDMI/DP", .patch
= patch_generic_hdmi
},
1899 { .id
= 0x10de0043, .name
= "GPU 43 HDMI/DP", .patch
= patch_generic_hdmi
},
1900 { .id
= 0x10de0044, .name
= "GPU 44 HDMI/DP", .patch
= patch_generic_hdmi
},
1901 { .id
= 0x10de0067, .name
= "MCP67 HDMI", .patch
= patch_nvhdmi_2ch
},
1902 { .id
= 0x10de8001, .name
= "MCP73 HDMI", .patch
= patch_nvhdmi_2ch
},
1903 { .id
= 0x80860054, .name
= "IbexPeak HDMI", .patch
= patch_generic_hdmi
},
1904 { .id
= 0x80862801, .name
= "Bearlake HDMI", .patch
= patch_generic_hdmi
},
1905 { .id
= 0x80862802, .name
= "Cantiga HDMI", .patch
= patch_generic_hdmi
},
1906 { .id
= 0x80862803, .name
= "Eaglelake HDMI", .patch
= patch_generic_hdmi
},
1907 { .id
= 0x80862804, .name
= "IbexPeak HDMI", .patch
= patch_generic_hdmi
},
1908 { .id
= 0x80862805, .name
= "CougarPoint HDMI", .patch
= patch_generic_hdmi
},
1909 { .id
= 0x80862806, .name
= "PantherPoint HDMI", .patch
= patch_generic_hdmi
},
1910 { .id
= 0x808629fb, .name
= "Crestline HDMI", .patch
= patch_generic_hdmi
},
1914 MODULE_ALIAS("snd-hda-codec-id:1002793c");
1915 MODULE_ALIAS("snd-hda-codec-id:10027919");
1916 MODULE_ALIAS("snd-hda-codec-id:1002791a");
1917 MODULE_ALIAS("snd-hda-codec-id:1002aa01");
1918 MODULE_ALIAS("snd-hda-codec-id:10951390");
1919 MODULE_ALIAS("snd-hda-codec-id:10951392");
1920 MODULE_ALIAS("snd-hda-codec-id:10de0002");
1921 MODULE_ALIAS("snd-hda-codec-id:10de0003");
1922 MODULE_ALIAS("snd-hda-codec-id:10de0005");
1923 MODULE_ALIAS("snd-hda-codec-id:10de0006");
1924 MODULE_ALIAS("snd-hda-codec-id:10de0007");
1925 MODULE_ALIAS("snd-hda-codec-id:10de000a");
1926 MODULE_ALIAS("snd-hda-codec-id:10de000b");
1927 MODULE_ALIAS("snd-hda-codec-id:10de000c");
1928 MODULE_ALIAS("snd-hda-codec-id:10de000d");
1929 MODULE_ALIAS("snd-hda-codec-id:10de0010");
1930 MODULE_ALIAS("snd-hda-codec-id:10de0011");
1931 MODULE_ALIAS("snd-hda-codec-id:10de0012");
1932 MODULE_ALIAS("snd-hda-codec-id:10de0013");
1933 MODULE_ALIAS("snd-hda-codec-id:10de0014");
1934 MODULE_ALIAS("snd-hda-codec-id:10de0015");
1935 MODULE_ALIAS("snd-hda-codec-id:10de0016");
1936 MODULE_ALIAS("snd-hda-codec-id:10de0018");
1937 MODULE_ALIAS("snd-hda-codec-id:10de0019");
1938 MODULE_ALIAS("snd-hda-codec-id:10de001a");
1939 MODULE_ALIAS("snd-hda-codec-id:10de001b");
1940 MODULE_ALIAS("snd-hda-codec-id:10de001c");
1941 MODULE_ALIAS("snd-hda-codec-id:10de0040");
1942 MODULE_ALIAS("snd-hda-codec-id:10de0041");
1943 MODULE_ALIAS("snd-hda-codec-id:10de0042");
1944 MODULE_ALIAS("snd-hda-codec-id:10de0043");
1945 MODULE_ALIAS("snd-hda-codec-id:10de0044");
1946 MODULE_ALIAS("snd-hda-codec-id:10de0067");
1947 MODULE_ALIAS("snd-hda-codec-id:10de8001");
1948 MODULE_ALIAS("snd-hda-codec-id:17e80047");
1949 MODULE_ALIAS("snd-hda-codec-id:80860054");
1950 MODULE_ALIAS("snd-hda-codec-id:80862801");
1951 MODULE_ALIAS("snd-hda-codec-id:80862802");
1952 MODULE_ALIAS("snd-hda-codec-id:80862803");
1953 MODULE_ALIAS("snd-hda-codec-id:80862804");
1954 MODULE_ALIAS("snd-hda-codec-id:80862805");
1955 MODULE_ALIAS("snd-hda-codec-id:80862806");
1956 MODULE_ALIAS("snd-hda-codec-id:808629fb");
1958 MODULE_LICENSE("GPL");
1959 MODULE_DESCRIPTION("HDMI HD-audio codec");
1960 MODULE_ALIAS("snd-hda-codec-intelhdmi");
1961 MODULE_ALIAS("snd-hda-codec-nvhdmi");
1962 MODULE_ALIAS("snd-hda-codec-atihdmi");
1964 static struct hda_codec_preset_list intel_list
= {
1965 .preset
= snd_hda_preset_hdmi
,
1966 .owner
= THIS_MODULE
,
1969 static int __init
patch_hdmi_init(void)
1971 return snd_hda_add_codec_preset(&intel_list
);
1974 static void __exit
patch_hdmi_exit(void)
1976 snd_hda_delete_codec_preset(&intel_list
);
1979 module_init(patch_hdmi_init
)
1980 module_exit(patch_hdmi_exit
)