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