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("HDMI: select CA 0x%x for %d-channel allocation: %s\n", 402 ai->CA, channels, buf); 403 404 return ai->CA; 405 } 406 407 static void hdmi_debug_channel_mapping(struct hda_codec *codec, 408 hda_nid_t pin_nid) 409 { 410 #ifdef CONFIG_SND_DEBUG_VERBOSE 411 int i; 412 int slot; 413 414 for (i = 0; i < 8; i++) { 415 slot = snd_hda_codec_read(codec, pin_nid, 0, 416 AC_VERB_GET_HDMI_CHAN_SLOT, i); 417 printk(KERN_DEBUG "HDMI: ASP channel %d => slot %d\n", 418 slot >> 4, slot & 0xf); 419 } 420 #endif 421 } 422 423 424 static void hdmi_setup_channel_mapping(struct hda_codec *codec, 425 hda_nid_t pin_nid, 426 struct hdmi_audio_infoframe *ai) 427 { 428 int i; 429 int ca = ai->CA; 430 int err; 431 432 if (hdmi_channel_mapping[ca][1] == 0) { 433 for (i = 0; i < channel_allocations[ca].channels; i++) 434 hdmi_channel_mapping[ca][i] = i | (i << 4); 435 for (; i < 8; i++) 436 hdmi_channel_mapping[ca][i] = 0xf | (i << 4); 437 } 438 439 for (i = 0; i < 8; i++) { 440 err = snd_hda_codec_write(codec, pin_nid, 0, 441 AC_VERB_SET_HDMI_CHAN_SLOT, 442 hdmi_channel_mapping[ca][i]); 443 if (err) { 444 snd_printdd(KERN_NOTICE 445 "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 snd_printdd("hdmi_setup_audio_infoframe: " 603 "cvt=%d pin=%d channels=%d\n", 604 nid, pin_nid, 605 substream->runtime->channels); 606 hdmi_setup_channel_mapping(codec, pin_nid, &ai); 607 hdmi_stop_infoframe_trans(codec, pin_nid); 608 hdmi_fill_audio_infoframe(codec, pin_nid, &ai); 609 hdmi_start_infoframe_trans(codec, pin_nid); 610 } 611 } 612 } 613 614 615 /* 616 * Unsolicited events 617 */ 618 619 static void hdmi_intrinsic_event(struct hda_codec *codec, unsigned int res) 620 { 621 struct hdmi_spec *spec = codec->spec; 622 int tag = res >> AC_UNSOL_RES_TAG_SHIFT; 623 int pind = !!(res & AC_UNSOL_RES_PD); 624 int eldv = !!(res & AC_UNSOL_RES_ELDV); 625 int index; 626 627 printk(KERN_INFO 628 "HDMI hot plug event: Pin=%d Presence_Detect=%d ELD_Valid=%d\n", 629 tag, pind, eldv); 630 631 index = hda_node_index(spec->pin, tag); 632 if (index < 0) 633 return; 634 635 spec->sink_eld[index].monitor_present = pind; 636 spec->sink_eld[index].eld_valid = eldv; 637 638 if (pind && eldv) { 639 hdmi_get_show_eld(codec, spec->pin[index], 640 &spec->sink_eld[index]); 641 /* TODO: do real things about ELD */ 642 } 643 } 644 645 static void hdmi_non_intrinsic_event(struct hda_codec *codec, unsigned int res) 646 { 647 int tag = res >> AC_UNSOL_RES_TAG_SHIFT; 648 int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT; 649 int cp_state = !!(res & AC_UNSOL_RES_CP_STATE); 650 int cp_ready = !!(res & AC_UNSOL_RES_CP_READY); 651 652 printk(KERN_INFO 653 "HDMI CP event: PIN=%d SUBTAG=0x%x CP_STATE=%d CP_READY=%d\n", 654 tag, 655 subtag, 656 cp_state, 657 cp_ready); 658 659 /* TODO */ 660 if (cp_state) 661 ; 662 if (cp_ready) 663 ; 664 } 665 666 667 static void hdmi_unsol_event(struct hda_codec *codec, unsigned int res) 668 { 669 struct hdmi_spec *spec = codec->spec; 670 int tag = res >> AC_UNSOL_RES_TAG_SHIFT; 671 int subtag = (res & AC_UNSOL_RES_SUBTAG) >> AC_UNSOL_RES_SUBTAG_SHIFT; 672 673 if (hda_node_index(spec->pin, tag) < 0) { 674 snd_printd(KERN_INFO "Unexpected HDMI event tag 0x%x\n", tag); 675 return; 676 } 677 678 if (subtag == 0) 679 hdmi_intrinsic_event(codec, res); 680 else 681 hdmi_non_intrinsic_event(codec, res); 682 } 683 684 /* 685 * Callbacks 686 */ 687 688 static void hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid, 689 u32 stream_tag, int format) 690 { 691 int tag; 692 int fmt; 693 694 tag = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0) >> 4; 695 fmt = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_STREAM_FORMAT, 0); 696 697 snd_printdd("hdmi_setup_stream: " 698 "NID=0x%x, %sstream=0x%x, %sformat=0x%x\n", 699 nid, 700 tag == stream_tag ? "" : "new-", 701 stream_tag, 702 fmt == format ? "" : "new-", 703 format); 704 705 if (tag != stream_tag) 706 snd_hda_codec_write(codec, nid, 0, 707 AC_VERB_SET_CHANNEL_STREAMID, 708 stream_tag << 4); 709 if (fmt != format) 710 snd_hda_codec_write(codec, nid, 0, 711 AC_VERB_SET_STREAM_FORMAT, format); 712 } 713 714 /* 715 * HDA/HDMI auto parsing 716 */ 717 718 static int hdmi_read_pin_conn(struct hda_codec *codec, hda_nid_t pin_nid) 719 { 720 struct hdmi_spec *spec = codec->spec; 721 hda_nid_t conn_list[HDA_MAX_CONNECTIONS]; 722 int conn_len, curr; 723 int index; 724 725 if (!(get_wcaps(codec, pin_nid) & AC_WCAP_CONN_LIST)) { 726 snd_printk(KERN_WARNING 727 "HDMI: pin %d wcaps %#x " 728 "does not support connection list\n", 729 pin_nid, get_wcaps(codec, pin_nid)); 730 return -EINVAL; 731 } 732 733 conn_len = snd_hda_get_connections(codec, pin_nid, conn_list, 734 HDA_MAX_CONNECTIONS); 735 if (conn_len > 1) 736 curr = snd_hda_codec_read(codec, pin_nid, 0, 737 AC_VERB_GET_CONNECT_SEL, 0); 738 else 739 curr = 0; 740 741 index = hda_node_index(spec->pin, pin_nid); 742 if (index < 0) 743 return -EINVAL; 744 745 spec->pin_cvt[index] = conn_list[curr]; 746 747 return 0; 748 } 749 750 static void hdmi_present_sense(struct hda_codec *codec, hda_nid_t pin_nid, 751 struct hdmi_eld *eld) 752 { 753 int present = snd_hda_pin_sense(codec, pin_nid); 754 755 eld->monitor_present = !!(present & AC_PINSENSE_PRESENCE); 756 eld->eld_valid = !!(present & AC_PINSENSE_ELDV); 757 758 if (present & AC_PINSENSE_ELDV) 759 hdmi_get_show_eld(codec, pin_nid, eld); 760 } 761 762 static int hdmi_add_pin(struct hda_codec *codec, hda_nid_t pin_nid) 763 { 764 struct hdmi_spec *spec = codec->spec; 765 766 if (spec->num_pins >= MAX_HDMI_PINS) { 767 snd_printk(KERN_WARNING 768 "HDMI: no space for pin %d\n", pin_nid); 769 return -EINVAL; 770 } 771 772 hdmi_present_sense(codec, pin_nid, &spec->sink_eld[spec->num_pins]); 773 774 spec->pin[spec->num_pins] = pin_nid; 775 spec->num_pins++; 776 777 /* 778 * It is assumed that converter nodes come first in the node list and 779 * hence have been registered and usable now. 780 */ 781 return hdmi_read_pin_conn(codec, pin_nid); 782 } 783 784 static int hdmi_add_cvt(struct hda_codec *codec, hda_nid_t nid) 785 { 786 struct hdmi_spec *spec = codec->spec; 787 788 if (spec->num_cvts >= MAX_HDMI_CVTS) { 789 snd_printk(KERN_WARNING 790 "HDMI: no space for converter %d\n", nid); 791 return -EINVAL; 792 } 793 794 spec->cvt[spec->num_cvts] = nid; 795 spec->num_cvts++; 796 797 return 0; 798 } 799 800 static int hdmi_parse_codec(struct hda_codec *codec) 801 { 802 hda_nid_t nid; 803 int i, nodes; 804 805 nodes = snd_hda_get_sub_nodes(codec, codec->afg, &nid); 806 if (!nid || nodes < 0) { 807 snd_printk(KERN_WARNING "HDMI: failed to get afg sub nodes\n"); 808 return -EINVAL; 809 } 810 811 for (i = 0; i < nodes; i++, nid++) { 812 unsigned int caps; 813 unsigned int type; 814 815 caps = snd_hda_param_read(codec, nid, AC_PAR_AUDIO_WIDGET_CAP); 816 type = get_wcaps_type(caps); 817 818 if (!(caps & AC_WCAP_DIGITAL)) 819 continue; 820 821 switch (type) { 822 case AC_WID_AUD_OUT: 823 if (hdmi_add_cvt(codec, nid) < 0) 824 return -EINVAL; 825 break; 826 case AC_WID_PIN: 827 caps = snd_hda_param_read(codec, nid, AC_PAR_PIN_CAP); 828 if (!(caps & (AC_PINCAP_HDMI | AC_PINCAP_DP))) 829 continue; 830 if (hdmi_add_pin(codec, nid) < 0) 831 return -EINVAL; 832 break; 833 } 834 } 835 836 /* 837 * G45/IbexPeak don't support EPSS: the unsolicited pin hot plug event 838 * can be lost and presence sense verb will become inaccurate if the 839 * HDA link is powered off at hot plug or hw initialization time. 840 */ 841 #ifdef CONFIG_SND_HDA_POWER_SAVE 842 if (!(snd_hda_param_read(codec, codec->afg, AC_PAR_POWER_STATE) & 843 AC_PWRST_EPSS)) 844 codec->bus->power_keep_link_on = 1; 845 #endif 846 847 return 0; 848 } 849 850