ALSA: hdmi - merge common code for intelhdmi and nvhdmi
[linux-2.6.git] / sound / pci / hda / patch_hdmi.c
1 /*
2  *
3  *  patch_hdmi.c - routines for HDMI/DisplayPort codecs
4  *
5  *  Copyright(c) 2008-2010 Intel Corporation. All rights reserved.
6  *
7  *  Authors:
8  *                      Wu Fengguang <wfg@linux.intel.com>
9  *
10  *  Maintained by:
11  *                      Wu Fengguang <wfg@linux.intel.com>
12  *
13  *  This program is free software; you can redistribute it and/or modify it
14  *  under the terms of the GNU General Public License as published by the Free
15  *  Software Foundation; either version 2 of the License, or (at your option)
16  *  any later version.
17  *
18  *  This program is distributed in the hope that it will be useful, but
19  *  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
20  *  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
21  *  for more details.
22  *
23  *  You should have received a copy of the GNU General Public License
24  *  along with this program; if not, write to the Free Software Foundation,
25  *  Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
26  */
27
28
29 struct hdmi_spec {
30         int num_cvts;
31         int num_pins;
32         hda_nid_t cvt[MAX_HDMI_CVTS+1];  /* audio sources */
33         hda_nid_t pin[MAX_HDMI_PINS+1];  /* audio sinks */
34
35         /*
36          * source connection for each pin
37          */
38         hda_nid_t pin_cvt[MAX_HDMI_PINS+1];
39
40         /*
41          * HDMI sink attached to each pin
42          */
43         struct hdmi_eld sink_eld[MAX_HDMI_PINS];
44
45         /*
46          * export one pcm per pipe
47          */
48         struct hda_pcm  pcm_rec[MAX_HDMI_CVTS];
49
50         /*
51          * nvhdmi specific
52          */
53         struct hda_multi_out multiout;
54         unsigned int codec_type;
55 };
56
57
58 struct hdmi_audio_infoframe {
59         u8 type; /* 0x84 */
60         u8 ver;  /* 0x01 */
61         u8 len;  /* 0x0a */
62
63         u8 checksum;    /* PB0 */
64         u8 CC02_CT47;   /* CC in bits 0:2, CT in 4:7 */
65         u8 SS01_SF24;
66         u8 CXT04;
67         u8 CA;
68         u8 LFEPBL01_LSV36_DM_INH7;
69         u8 reserved[5]; /* PB6 - PB10 */
70 };
71
72 /*
73  * CEA speaker placement:
74  *
75  *        FLH       FCH        FRH
76  *  FLW    FL  FLC   FC   FRC   FR   FRW
77  *
78  *                                  LFE
79  *                     TC
80  *
81  *          RL  RLC   RC   RRC   RR
82  *
83  * The Left/Right Surround channel _notions_ LS/RS in SMPTE 320M corresponds to
84  * CEA RL/RR; The SMPTE channel _assignment_ C/LFE is swapped to CEA LFE/FC.
85  */
86 enum cea_speaker_placement {
87         FL  = (1 <<  0),        /* Front Left           */
88         FC  = (1 <<  1),        /* Front Center         */
89         FR  = (1 <<  2),        /* Front Right          */
90         FLC = (1 <<  3),        /* Front Left Center    */
91         FRC = (1 <<  4),        /* Front Right Center   */
92         RL  = (1 <<  5),        /* Rear Left            */
93         RC  = (1 <<  6),        /* Rear Center          */
94         RR  = (1 <<  7),        /* Rear Right           */
95         RLC = (1 <<  8),        /* Rear Left Center     */
96         RRC = (1 <<  9),        /* Rear Right Center    */
97         LFE = (1 << 10),        /* Low Frequency Effect */
98         FLW = (1 << 11),        /* Front Left Wide      */
99         FRW = (1 << 12),        /* Front Right Wide     */
100         FLH = (1 << 13),        /* Front Left High      */
101         FCH = (1 << 14),        /* Front Center High    */
102         FRH = (1 << 15),        /* Front Right High     */
103         TC  = (1 << 16),        /* Top Center           */
104 };
105
106 /*
107  * ELD SA bits in the CEA Speaker Allocation data block
108  */
109 static int eld_speaker_allocation_bits[] = {
110         [0] = FL | FR,
111         [1] = LFE,
112         [2] = FC,
113         [3] = RL | RR,
114         [4] = RC,
115         [5] = FLC | FRC,
116         [6] = RLC | RRC,
117         /* the following are not defined in ELD yet */
118         [7] = FLW | FRW,
119         [8] = FLH | FRH,
120         [9] = TC,
121         [10] = FCH,
122 };
123
124 struct cea_channel_speaker_allocation {
125         int ca_index;
126         int speakers[8];
127
128         /* derived values, just for convenience */
129         int channels;
130         int spk_mask;
131 };
132
133 /*
134  * ALSA sequence is:
135  *
136  *       surround40   surround41   surround50   surround51   surround71
137  * ch0   front left   =            =            =            =
138  * ch1   front right  =            =            =            =
139  * ch2   rear left    =            =            =            =
140  * ch3   rear right   =            =            =            =
141  * ch4                LFE          center       center       center
142  * ch5                                          LFE          LFE
143  * ch6                                                       side left
144  * ch7                                                       side right
145  *
146  * surround71 = {FL, FR, RLC, RRC, FC, LFE, RL, RR}
147  */
148 static int hdmi_channel_mapping[0x32][8] = {
149         /* stereo */
150         [0x00] = { 0x00, 0x11, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
151         /* 2.1 */
152         [0x01] = { 0x00, 0x11, 0x22, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7 },
153         /* Dolby Surround */
154         [0x02] = { 0x00, 0x11, 0x23, 0xf2, 0xf4, 0xf5, 0xf6, 0xf7 },
155         /* surround40 */
156         [0x08] = { 0x00, 0x11, 0x24, 0x35, 0xf3, 0xf2, 0xf6, 0xf7 },
157         /* 4ch */
158         [0x03] = { 0x00, 0x11, 0x23, 0x32, 0x44, 0xf5, 0xf6, 0xf7 },
159         /* surround41 */
160         [0x09] = { 0x00, 0x11, 0x24, 0x34, 0x43, 0xf2, 0xf6, 0xf7 },
161         /* surround50 */
162         [0x0a] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0xf2, 0xf6, 0xf7 },
163         /* surround51 */
164         [0x0b] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0x52, 0xf6, 0xf7 },
165         /* 7.1 */
166         [0x13] = { 0x00, 0x11, 0x26, 0x37, 0x43, 0x52, 0x64, 0x75 },
167 };
168
169 /*
170  * This is an ordered list!
171  *
172  * The preceding ones have better chances to be selected by
173  * hdmi_setup_channel_allocation().
174  */
175 static struct cea_channel_speaker_allocation channel_allocations[] = {
176 /*                        channel:   7     6    5    4    3     2    1    0  */
177 { .ca_index = 0x00,  .speakers = {   0,    0,   0,   0,   0,    0,  FR,  FL } },
178                                  /* 2.1 */
179 { .ca_index = 0x01,  .speakers = {   0,    0,   0,   0,   0,  LFE,  FR,  FL } },
180                                  /* Dolby Surround */
181 { .ca_index = 0x02,  .speakers = {   0,    0,   0,   0,  FC,    0,  FR,  FL } },
182                                  /* surround40 */
183 { .ca_index = 0x08,  .speakers = {   0,    0,  RR,  RL,   0,    0,  FR,  FL } },
184                                  /* surround41 */
185 { .ca_index = 0x09,  .speakers = {   0,    0,  RR,  RL,   0,  LFE,  FR,  FL } },
186                                  /* surround50 */
187 { .ca_index = 0x0a,  .speakers = {   0,    0,  RR,  RL,  FC,    0,  FR,  FL } },
188                                  /* surround51 */
189 { .ca_index = 0x0b,  .speakers = {   0,    0,  RR,  RL,  FC,  LFE,  FR,  FL } },
190                                  /* 6.1 */
191 { .ca_index = 0x0f,  .speakers = {   0,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
192                                  /* surround71 */
193 { .ca_index = 0x13,  .speakers = { RRC,  RLC,  RR,  RL,  FC,  LFE,  FR,  FL } },
194
195 { .ca_index = 0x03,  .speakers = {   0,    0,   0,   0,  FC,  LFE,  FR,  FL } },
196 { .ca_index = 0x04,  .speakers = {   0,    0,   0,  RC,   0,    0,  FR,  FL } },
197 { .ca_index = 0x05,  .speakers = {   0,    0,   0,  RC,   0,  LFE,  FR,  FL } },
198 { .ca_index = 0x06,  .speakers = {   0,    0,   0,  RC,  FC,    0,  FR,  FL } },
199 { .ca_index = 0x07,  .speakers = {   0,    0,   0,  RC,  FC,  LFE,  FR,  FL } },
200 { .ca_index = 0x0c,  .speakers = {   0,   RC,  RR,  RL,   0,    0,  FR,  FL } },
201 { .ca_index = 0x0d,  .speakers = {   0,   RC,  RR,  RL,   0,  LFE,  FR,  FL } },
202 { .ca_index = 0x0e,  .speakers = {   0,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
203 { .ca_index = 0x10,  .speakers = { RRC,  RLC,  RR,  RL,   0,    0,  FR,  FL } },
204 { .ca_index = 0x11,  .speakers = { RRC,  RLC,  RR,  RL,   0,  LFE,  FR,  FL } },
205 { .ca_index = 0x12,  .speakers = { RRC,  RLC,  RR,  RL,  FC,    0,  FR,  FL } },
206 { .ca_index = 0x14,  .speakers = { FRC,  FLC,   0,   0,   0,    0,  FR,  FL } },
207 { .ca_index = 0x15,  .speakers = { FRC,  FLC,   0,   0,   0,  LFE,  FR,  FL } },
208 { .ca_index = 0x16,  .speakers = { FRC,  FLC,   0,   0,  FC,    0,  FR,  FL } },
209 { .ca_index = 0x17,  .speakers = { FRC,  FLC,   0,   0,  FC,  LFE,  FR,  FL } },
210 { .ca_index = 0x18,  .speakers = { FRC,  FLC,   0,  RC,   0,    0,  FR,  FL } },
211 { .ca_index = 0x19,  .speakers = { FRC,  FLC,   0,  RC,   0,  LFE,  FR,  FL } },
212 { .ca_index = 0x1a,  .speakers = { FRC,  FLC,   0,  RC,  FC,    0,  FR,  FL } },
213 { .ca_index = 0x1b,  .speakers = { FRC,  FLC,   0,  RC,  FC,  LFE,  FR,  FL } },
214 { .ca_index = 0x1c,  .speakers = { FRC,  FLC,  RR,  RL,   0,    0,  FR,  FL } },
215 { .ca_index = 0x1d,  .speakers = { FRC,  FLC,  RR,  RL,   0,  LFE,  FR,  FL } },
216 { .ca_index = 0x1e,  .speakers = { FRC,  FLC,  RR,  RL,  FC,    0,  FR,  FL } },
217 { .ca_index = 0x1f,  .speakers = { FRC,  FLC,  RR,  RL,  FC,  LFE,  FR,  FL } },
218 { .ca_index = 0x20,  .speakers = {   0,  FCH,  RR,  RL,  FC,    0,  FR,  FL } },
219 { .ca_index = 0x21,  .speakers = {   0,  FCH,  RR,  RL,  FC,  LFE,  FR,  FL } },
220 { .ca_index = 0x22,  .speakers = {  TC,    0,  RR,  RL,  FC,    0,  FR,  FL } },
221 { .ca_index = 0x23,  .speakers = {  TC,    0,  RR,  RL,  FC,  LFE,  FR,  FL } },
222 { .ca_index = 0x24,  .speakers = { FRH,  FLH,  RR,  RL,   0,    0,  FR,  FL } },
223 { .ca_index = 0x25,  .speakers = { FRH,  FLH,  RR,  RL,   0,  LFE,  FR,  FL } },
224 { .ca_index = 0x26,  .speakers = { FRW,  FLW,  RR,  RL,   0,    0,  FR,  FL } },
225 { .ca_index = 0x27,  .speakers = { FRW,  FLW,  RR,  RL,   0,  LFE,  FR,  FL } },
226 { .ca_index = 0x28,  .speakers = {  TC,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
227 { .ca_index = 0x29,  .speakers = {  TC,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
228 { .ca_index = 0x2a,  .speakers = { FCH,   RC,  RR,  RL,  FC,    0,  FR,  FL } },
229 { .ca_index = 0x2b,  .speakers = { FCH,   RC,  RR,  RL,  FC,  LFE,  FR,  FL } },
230 { .ca_index = 0x2c,  .speakers = {  TC,  FCH,  RR,  RL,  FC,    0,  FR,  FL } },
231 { .ca_index = 0x2d,  .speakers = {  TC,  FCH,  RR,  RL,  FC,  LFE,  FR,  FL } },
232 { .ca_index = 0x2e,  .speakers = { FRH,  FLH,  RR,  RL,  FC,    0,  FR,  FL } },
233 { .ca_index = 0x2f,  .speakers = { FRH,  FLH,  RR,  RL,  FC,  LFE,  FR,  FL } },
234 { .ca_index = 0x30,  .speakers = { FRW,  FLW,  RR,  RL,  FC,    0,  FR,  FL } },
235 { .ca_index = 0x31,  .speakers = { FRW,  FLW,  RR,  RL,  FC,  LFE,  FR,  FL } },
236 };
237
238
239 /*
240  * HDMI routines
241  */
242
243 static int hda_node_index(hda_nid_t *nids, hda_nid_t nid)
244 {
245         int i;
246
247         for (i = 0; nids[i]; i++)
248                 if (nids[i] == nid)
249                         return i;
250
251         snd_printk(KERN_WARNING "HDMI: nid %d not registered\n", nid);
252         return -EINVAL;
253 }
254
255 static void hdmi_get_show_eld(struct hda_codec *codec, hda_nid_t pin_nid,
256                               struct hdmi_eld *eld)
257 {
258         if (!snd_hdmi_get_eld(eld, codec, pin_nid))
259                 snd_hdmi_show_eld(eld);
260 }
261
262 #ifdef BE_PARANOID
263 static void hdmi_get_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
264                                 int *packet_index, int *byte_index)
265 {
266         int val;
267
268         val = snd_hda_codec_read(codec, pin_nid, 0,
269                                  AC_VERB_GET_HDMI_DIP_INDEX, 0);
270
271         *packet_index = val >> 5;
272         *byte_index = val & 0x1f;
273 }
274 #endif
275
276 static void hdmi_set_dip_index(struct hda_codec *codec, hda_nid_t pin_nid,
277                                 int packet_index, int byte_index)
278 {
279         int val;
280
281         val = (packet_index << 5) | (byte_index & 0x1f);
282
283         snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_INDEX, val);
284 }
285
286 static void hdmi_write_dip_byte(struct hda_codec *codec, hda_nid_t pin_nid,
287                                 unsigned char val)
288 {
289         snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_DATA, val);
290 }
291
292 static void hdmi_enable_output(struct hda_codec *codec, hda_nid_t pin_nid)
293 {
294         /* Unmute */
295         if (get_wcaps(codec, pin_nid) & AC_WCAP_OUT_AMP)
296                 snd_hda_codec_write(codec, pin_nid, 0,
297                                 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE);
298         /* Enable pin out */
299         snd_hda_codec_write(codec, pin_nid, 0,
300                             AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
301 }
302
303 static int hdmi_get_channel_count(struct hda_codec *codec, hda_nid_t nid)
304 {
305         return 1 + snd_hda_codec_read(codec, nid, 0,
306                                         AC_VERB_GET_CVT_CHAN_COUNT, 0);
307 }
308
309 static void hdmi_set_channel_count(struct hda_codec *codec,
310                                    hda_nid_t nid, int chs)
311 {
312         if (chs != hdmi_get_channel_count(codec, nid))
313                 snd_hda_codec_write(codec, nid, 0,
314                                     AC_VERB_SET_CVT_CHAN_COUNT, chs - 1);
315 }
316
317
318 /*
319  * Channel mapping routines
320  */
321
322 /*
323  * Compute derived values in channel_allocations[].
324  */
325 static void init_channel_allocations(void)
326 {
327         int i, j;
328         struct cea_channel_speaker_allocation *p;
329
330         for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
331                 p = channel_allocations + i;
332                 p->channels = 0;
333                 p->spk_mask = 0;
334                 for (j = 0; j < ARRAY_SIZE(p->speakers); j++)
335                         if (p->speakers[j]) {
336                                 p->channels++;
337                                 p->spk_mask |= p->speakers[j];
338                         }
339         }
340 }
341
342 /*
343  * The transformation takes two steps:
344  *
345  *      eld->spk_alloc => (eld_speaker_allocation_bits[]) => spk_mask
346  *            spk_mask => (channel_allocations[])         => ai->CA
347  *
348  * TODO: it could select the wrong CA from multiple candidates.
349 */
350 static int hdmi_setup_channel_allocation(struct hda_codec *codec, hda_nid_t nid,
351                                          struct hdmi_audio_infoframe *ai)
352 {
353         struct hdmi_spec *spec = codec->spec;
354         struct hdmi_eld *eld;
355         int i;
356         int spk_mask = 0;
357         int channels = 1 + (ai->CC02_CT47 & 0x7);
358         char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE];
359
360         /*
361          * CA defaults to 0 for basic stereo audio
362          */
363         if (channels <= 2)
364                 return 0;
365
366         i = hda_node_index(spec->pin_cvt, nid);
367         if (i < 0)
368                 return 0;
369         eld = &spec->sink_eld[i];
370
371         /*
372          * HDMI sink's ELD info cannot always be retrieved for now, e.g.
373          * in console or for audio devices. Assume the highest speakers
374          * configuration, to _not_ prohibit multi-channel audio playback.
375          */
376         if (!eld->spk_alloc)
377                 eld->spk_alloc = 0xffff;
378
379         /*
380          * expand ELD's speaker allocation mask
381          *
382          * ELD tells the speaker mask in a compact(paired) form,
383          * expand ELD's notions to match the ones used by Audio InfoFrame.
384          */
385         for (i = 0; i < ARRAY_SIZE(eld_speaker_allocation_bits); i++) {
386                 if (eld->spk_alloc & (1 << i))
387                         spk_mask |= eld_speaker_allocation_bits[i];
388         }
389
390         /* search for the first working match in the CA table */
391         for (i = 0; i < ARRAY_SIZE(channel_allocations); i++) {
392                 if (channels == channel_allocations[i].channels &&
393                     (spk_mask & channel_allocations[i].spk_mask) ==
394                                 channel_allocations[i].spk_mask) {
395                         ai->CA = channel_allocations[i].ca_index;
396                         break;
397                 }
398         }
399
400         snd_print_channel_allocation(eld->spk_alloc, buf, sizeof(buf));
401         snd_printdd(KERN_INFO
402                         "HDMI: select CA 0x%x for %d-channel allocation: %s\n",
403                         ai->CA, channels, buf);
404
405         return ai->CA;
406 }
407
408 static void hdmi_debug_channel_mapping(struct hda_codec *codec,
409                                        hda_nid_t pin_nid)
410 {
411 #ifdef CONFIG_SND_DEBUG_VERBOSE
412         int i;
413         int slot;
414
415         for (i = 0; i < 8; i++) {
416                 slot = snd_hda_codec_read(codec, pin_nid, 0,
417                                                 AC_VERB_GET_HDMI_CHAN_SLOT, i);
418                 printk(KERN_DEBUG "HDMI: ASP channel %d => slot %d\n",
419                                                 slot >> 4, slot & 0xf);
420         }
421 #endif
422 }
423
424
425 static void hdmi_setup_channel_mapping(struct hda_codec *codec,
426                                        hda_nid_t pin_nid,
427                                        struct hdmi_audio_infoframe *ai)
428 {
429         int i;
430         int ca = ai->CA;
431         int err;
432
433         if (hdmi_channel_mapping[ca][1] == 0) {
434                 for (i = 0; i < channel_allocations[ca].channels; i++)
435                         hdmi_channel_mapping[ca][i] = i | (i << 4);
436                 for (; i < 8; i++)
437                         hdmi_channel_mapping[ca][i] = 0xf | (i << 4);
438         }
439
440         for (i = 0; i < 8; i++) {
441                 err = snd_hda_codec_write(codec, pin_nid, 0,
442                                           AC_VERB_SET_HDMI_CHAN_SLOT,
443                                           hdmi_channel_mapping[ca][i]);
444                 if (err) {
445                         snd_printdd(KERN_INFO "HDMI: channel mapping failed\n");
446                         break;
447                 }
448         }
449
450         hdmi_debug_channel_mapping(codec, pin_nid);
451 }
452
453
454 /*
455  * Audio InfoFrame routines
456  */
457
458 /*
459  * Enable Audio InfoFrame Transmission
460  */
461 static void hdmi_start_infoframe_trans(struct hda_codec *codec,
462                                        hda_nid_t pin_nid)
463 {
464         hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
465         snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
466                                                 AC_DIPXMIT_BEST);
467 }
468
469 /*
470  * Disable Audio InfoFrame Transmission
471  */
472 static void hdmi_stop_infoframe_trans(struct hda_codec *codec,
473                                       hda_nid_t pin_nid)
474 {
475         hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
476         snd_hda_codec_write(codec, pin_nid, 0, AC_VERB_SET_HDMI_DIP_XMIT,
477                                                 AC_DIPXMIT_DISABLE);
478 }
479
480 static void hdmi_debug_dip_size(struct hda_codec *codec, hda_nid_t pin_nid)
481 {
482 #ifdef CONFIG_SND_DEBUG_VERBOSE
483         int i;
484         int size;
485
486         size = snd_hdmi_get_eld_size(codec, pin_nid);
487         printk(KERN_DEBUG "HDMI: ELD buf size is %d\n", size);
488
489         for (i = 0; i < 8; i++) {
490                 size = snd_hda_codec_read(codec, pin_nid, 0,
491                                                 AC_VERB_GET_HDMI_DIP_SIZE, i);
492                 printk(KERN_DEBUG "HDMI: DIP GP[%d] buf size is %d\n", i, size);
493         }
494 #endif
495 }
496
497 static void hdmi_clear_dip_buffers(struct hda_codec *codec, hda_nid_t pin_nid)
498 {
499 #ifdef BE_PARANOID
500         int i, j;
501         int size;
502         int pi, bi;
503         for (i = 0; i < 8; i++) {
504                 size = snd_hda_codec_read(codec, pin_nid, 0,
505                                                 AC_VERB_GET_HDMI_DIP_SIZE, i);
506                 if (size == 0)
507                         continue;
508
509                 hdmi_set_dip_index(codec, pin_nid, i, 0x0);
510                 for (j = 1; j < 1000; j++) {
511                         hdmi_write_dip_byte(codec, pin_nid, 0x0);
512                         hdmi_get_dip_index(codec, pin_nid, &pi, &bi);
513                         if (pi != i)
514                                 snd_printd(KERN_INFO "dip index %d: %d != %d\n",
515                                                 bi, pi, i);
516                         if (bi == 0) /* byte index wrapped around */
517                                 break;
518                 }
519                 snd_printd(KERN_INFO
520                         "HDMI: DIP GP[%d] buf reported size=%d, written=%d\n",
521                         i, size, j);
522         }
523 #endif
524 }
525
526 static void hdmi_checksum_audio_infoframe(struct hdmi_audio_infoframe *ai)
527 {
528         u8 *bytes = (u8 *)ai;
529         u8 sum = 0;
530         int i;
531
532         ai->checksum = 0;
533
534         for (i = 0; i < sizeof(*ai); i++)
535                 sum += bytes[i];
536
537         ai->checksum = -sum;
538 }
539
540 static void hdmi_fill_audio_infoframe(struct hda_codec *codec,
541                                       hda_nid_t pin_nid,
542                                       struct hdmi_audio_infoframe *ai)
543 {
544         u8 *bytes = (u8 *)ai;
545         int i;
546
547         hdmi_debug_dip_size(codec, pin_nid);
548         hdmi_clear_dip_buffers(codec, pin_nid); /* be paranoid */
549
550         hdmi_checksum_audio_infoframe(ai);
551
552         hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
553         for (i = 0; i < sizeof(*ai); i++)
554                 hdmi_write_dip_byte(codec, pin_nid, bytes[i]);
555 }
556
557 static bool hdmi_infoframe_uptodate(struct hda_codec *codec, hda_nid_t pin_nid,
558                                     struct hdmi_audio_infoframe *ai)
559 {
560         u8 *bytes = (u8 *)ai;
561         u8 val;
562         int i;
563
564         if (snd_hda_codec_read(codec, pin_nid, 0, AC_VERB_GET_HDMI_DIP_XMIT, 0)
565                                                             != AC_DIPXMIT_BEST)
566                 return false;
567
568         hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0);
569         for (i = 0; i < sizeof(*ai); i++) {
570                 val = snd_hda_codec_read(codec, pin_nid, 0,
571                                          AC_VERB_GET_HDMI_DIP_DATA, 0);
572                 if (val != bytes[i])
573                         return false;
574         }
575
576         return true;
577 }
578
579 static void hdmi_setup_audio_infoframe(struct hda_codec *codec, hda_nid_t nid,
580                                         struct snd_pcm_substream *substream)
581 {
582         struct hdmi_spec *spec = codec->spec;
583         hda_nid_t pin_nid;
584         int i;
585         struct hdmi_audio_infoframe ai = {
586                 .type           = 0x84,
587                 .ver            = 0x01,
588                 .len            = 0x0a,
589                 .CC02_CT47      = substream->runtime->channels - 1,
590         };
591
592         hdmi_setup_channel_allocation(codec, nid, &ai);
593
594         for (i = 0; i < spec->num_pins; i++) {
595                 if (spec->pin_cvt[i] != nid)
596                         continue;
597                 if (!spec->sink_eld[i].monitor_present)
598                         continue;
599
600                 pin_nid = spec->pin[i];
601                 if (!hdmi_infoframe_uptodate(codec, pin_nid, &ai)) {
602                         hdmi_setup_channel_mapping(codec, pin_nid, &ai);
603                         hdmi_stop_infoframe_trans(codec, pin_nid);
604                         hdmi_fill_audio_infoframe(codec, pin_nid, &ai);
605                         hdmi_start_infoframe_trans(codec, pin_nid);
606                 }
607         }
608 }
609
610
611 /*
612  * Unsolicited events
613  */
614
615 static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res)
616 {
617         struct hdmi_spec *spec = codec->spec;
618         int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
619         int pind = !!(res & AC_UNSOL_RES_PD);
620         int eldv = !!(res & AC_UNSOL_RES_ELDV);
621         int index;
622
623         printk(KERN_INFO
624                 "HDMI hot plug event: Pin=%d Presence_Detect=%d ELD_Valid=%d\n",
625                 tag, pind, eldv);
626
627         index = hda_node_index(spec->pin, tag);
628         if (index < 0)
629                 return;
630
631         spec->sink_eld[index].monitor_present = pind;
632         spec->sink_eld[index].eld_valid = eldv;
633
634         if (pind && eldv) {
635                 hdmi_get_show_eld(codec, spec->pin[index],
636                                   &spec->sink_eld[index]);
637                 /* TODO: do real things about ELD */
638         }
639 }
640
641 static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res)
642 {
643         int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
644         int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
645         int cp_state = !!(res & AC_UNSOL_RES_CP_STATE);
646         int cp_ready = !!(res & AC_UNSOL_RES_CP_READY);
647
648         printk(KERN_INFO
649                 "HDMI CP event: PIN=%d SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n",
650                 tag,
651                 subtag,
652                 cp_state,
653                 cp_ready);
654
655         /* TODO */
656         if (cp_state)
657                 ;
658         if (cp_ready)
659                 ;
660 }
661
662
663 static void hdmi_unsol_event(struct hda_codec *codec, unsigned int res)
664 {
665         struct hdmi_spec *spec = codec->spec;
666         int tag = res >> AC_UNSOL_RES_TAG_SHIFT;
667         int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT;
668
669         if (hda_node_index(spec->pin, tag) < 0) {
670                 snd_printd(KERN_INFO "Unexpected HDMI event tag 0x%x\n", tag);
671                 return;
672         }
673
674         if (subtag == 0)
675                 hdmi_intrinsic_event(codec, res);
676         else
677                 hdmi_non_intrinsic_event(codec, res);
678 }
679
680 /*
681  * Callbacks
682  */
683
684 static void hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid,
685                               u32 stream_tag, int format)
686 {
687         int tag;
688         int fmt;
689
690         tag = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0) >> 4;
691         fmt = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_STREAM_FORMAT, 0);
692
693         snd_printdd("hdmi_setup_stream: "
694                     "NID=0x%x, %sstream=0x%x, %sformat=0x%x\n",
695                     nid,
696                     tag == stream_tag ? "" : "new-",
697                     stream_tag,
698                     fmt == format ? "" : "new-",
699                     format);
700
701         if (tag != stream_tag)
702                 snd_hda_codec_write(codec, nid, 0,
703                                     AC_VERB_SET_CHANNEL_STREAMID,
704                                     stream_tag << 4);
705         if (fmt != format)
706                 snd_hda_codec_write(codec, nid, 0,
707                                     AC_VERB_SET_STREAM_FORMAT, format);
708 }
709
710 /*
711  * HDA/HDMI auto parsing
712  */
713
714 static int hdmi_read_pin_conn(struct hda_codec *codec, hda_nid_t pin_nid)
715 {
716         struct hdmi_spec *spec = codec->spec;
717         hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
718         int conn_len, curr;
719         int index;
720
721         if (!(get_wcaps(codec, pin_nid) & AC_WCAP_CONN_LIST)) {
722                 snd_printk(KERN_WARNING
723                            "HDMI: pin %d wcaps %#x "
724                            "does not support connection list\n",
725                            pin_nid, get_wcaps(codec, pin_nid));
726                 return -EINVAL;
727         }
728
729         conn_len = snd_hda_get_connections(codec, pin_nid, conn_list,
730                                            HDA_MAX_CONNECTIONS);
731         if (conn_len > 1)
732                 curr = snd_hda_codec_read(codec, pin_nid, 0,
733                                           AC_VERB_GET_CONNECT_SEL, 0);
734         else
735                 curr = 0;
736
737         index = hda_node_index(spec->pin, pin_nid);
738         if (index < 0)
739                 return -EINVAL;
740
741         spec->pin_cvt[index] = conn_list[curr];
742
743         return 0;
744 }
745
746 static void hdmi_present_sense(struct hda_codec *codec, hda_nid_t pin_nid,
747                                struct hdmi_eld *eld)
748 {
749         int present = snd_hda_pin_sense(codec, pin_nid);
750
751         eld->monitor_present    = !!(present & AC_PINSENSE_PRESENCE);
752         eld->eld_valid          = !!(present & AC_PINSENSE_ELDV);
753
754         if (present & AC_PINSENSE_ELDV)
755                 hdmi_get_show_eld(codec, pin_nid, eld);
756 }
757
758 static int hdmi_add_pin(struct hda_codec *codec, hda_nid_t pin_nid)
759 {
760         struct hdmi_spec *spec = codec->spec;
761
762         if (spec->num_pins >= MAX_HDMI_PINS) {
763                 snd_printk(KERN_WARNING
764                            "HDMI: no space for pin %d\n", pin_nid);
765                 return -EINVAL;
766         }
767
768         hdmi_present_sense(codec, pin_nid, &spec->sink_eld[spec->num_pins]);
769
770         spec->pin[spec->num_pins] = pin_nid;
771         spec->num_pins++;
772
773         /*
774          * It is assumed that converter nodes come first in the node list and
775          * hence have been registered and usable now.
776          */
777         return hdmi_read_pin_conn(codec, pin_nid);
778 }
779
780 static int hdmi_add_cvt(struct hda_codec *codec, hda_nid_t nid)
781 {
782         struct hdmi_spec *spec = codec->spec;
783
784         if (spec->num_cvts >= MAX_HDMI_CVTS) {
785                 snd_printk(KERN_WARNING
786                            "HDMI: no space for converter %d\n", nid);
787                 return -EINVAL;
788         }
789
790         spec->cvt[spec->num_cvts] = nid;
791         spec->num_cvts++;
792
793         return 0;
794 }
795
796 static int hdmi_parse_codec(struct hda_codec *codec)
797 {
798         hda_nid_t nid;
799         int i, nodes;
800
801         nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid);
802         if (!nid || nodes < 0) {
803                 snd_printk(KERN_WARNING "HDMI: failed to get afg sub nodes\n");
804                 return -EINVAL;
805         }
806
807         for (i = 0; i < nodes; i++, nid++) {
808                 unsigned int caps;
809                 unsigned int type;
810
811                 caps = snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP);
812                 type = get_wcaps_type(caps);
813
814                 if (!(caps & AC_WCAP_DIGITAL))
815                         continue;
816
817                 switch (type) {
818                 case AC_WID_AUD_OUT:
819                         if (hdmi_add_cvt(codec, nid) < 0)
820                                 return -EINVAL;
821                         break;
822                 case AC_WID_PIN:
823                         caps = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP);
824                         if (!(caps & (AC_PINCAP_HDMI | AC_PINCAP_DP)))
825                                 continue;
826                         if (hdmi_add_pin(codec, nid) < 0)
827                                 return -EINVAL;
828                         break;
829                 }
830         }
831
832         /*
833          * G45/IbexPeak don't support EPSS: the unsolicited pin hot plug event
834          * can be lost and presence sense verb will become inaccurate if the
835          * HDA link is powered off at hot plug or hw initialization time.
836          */
837 #ifdef CONFIG_SND_HDA_POWER_SAVE
838         if (!(snd_hda_param_read(codec, codec->afg, AC_PAR_POWER_STATE) &
839               AC_PWRST_EPSS))
840                 codec->bus->power_keep_link_on = 1;
841 #endif
842
843         return 0;
844 }
845