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