1 /* 2 * hdac_hdmi.c - ASoc HDA-HDMI codec driver for Intel platforms 3 * 4 * Copyright (C) 2014-2015 Intel Corp 5 * Author: Samreen Nilofer <samreen.nilofer@intel.com> 6 * Subhransu S. Prusty <subhransu.s.prusty@intel.com> 7 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; version 2 of the License. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 19 */ 20 #include <linux/init.h> 21 #include <linux/delay.h> 22 #include <linux/module.h> 23 #include <linux/pm_runtime.h> 24 #include <linux/hdmi.h> 25 #include <drm/drm_edid.h> 26 #include <sound/pcm_params.h> 27 #include <sound/jack.h> 28 #include <sound/soc.h> 29 #include <sound/hdaudio_ext.h> 30 #include <sound/hda_i915.h> 31 #include <sound/pcm_drm_eld.h> 32 #include "../../hda/local.h" 33 #include "hdac_hdmi.h" 34 35 #define NAME_SIZE 32 36 37 #define AMP_OUT_MUTE 0xb080 38 #define AMP_OUT_UNMUTE 0xb000 39 #define PIN_OUT (AC_PINCTL_OUT_EN) 40 41 #define HDA_MAX_CONNECTIONS 32 42 43 #define HDA_MAX_CVTS 3 44 45 #define ELD_MAX_SIZE 256 46 #define ELD_FIXED_BYTES 20 47 48 struct hdac_hdmi_cvt_params { 49 unsigned int channels_min; 50 unsigned int channels_max; 51 u32 rates; 52 u64 formats; 53 unsigned int maxbps; 54 }; 55 56 struct hdac_hdmi_cvt { 57 struct list_head head; 58 hda_nid_t nid; 59 const char *name; 60 struct hdac_hdmi_cvt_params params; 61 }; 62 63 struct hdac_hdmi_eld { 64 bool monitor_present; 65 bool eld_valid; 66 int eld_size; 67 char eld_buffer[ELD_MAX_SIZE]; 68 }; 69 70 struct hdac_hdmi_pin { 71 struct list_head head; 72 hda_nid_t nid; 73 int num_mux_nids; 74 hda_nid_t mux_nids[HDA_MAX_CONNECTIONS]; 75 struct hdac_hdmi_eld eld; 76 struct hdac_ext_device *edev; 77 int repoll_count; 78 struct delayed_work work; 79 }; 80 81 struct hdac_hdmi_pcm { 82 struct list_head head; 83 int pcm_id; 84 struct hdac_hdmi_pin *pin; 85 struct hdac_hdmi_cvt *cvt; 86 struct snd_jack *jack; 87 }; 88 89 struct hdac_hdmi_dai_pin_map { 90 int dai_id; 91 struct hdac_hdmi_pin *pin; 92 struct hdac_hdmi_cvt *cvt; 93 }; 94 95 struct hdac_hdmi_priv { 96 struct hdac_hdmi_dai_pin_map dai_map[HDA_MAX_CVTS]; 97 struct list_head pin_list; 98 struct list_head cvt_list; 99 struct list_head pcm_list; 100 int num_pin; 101 int num_cvt; 102 struct mutex pin_mutex; 103 }; 104 105 static inline struct hdac_ext_device *to_hda_ext_device(struct device *dev) 106 { 107 struct hdac_device *hdac = dev_to_hdac_dev(dev); 108 109 return to_ehdac_device(hdac); 110 } 111 112 static unsigned int sad_format(const u8 *sad) 113 { 114 return ((sad[0] >> 0x3) & 0x1f); 115 } 116 117 static unsigned int sad_sample_bits_lpcm(const u8 *sad) 118 { 119 return (sad[2] & 7); 120 } 121 122 static int hdac_hdmi_eld_limit_formats(struct snd_pcm_runtime *runtime, 123 void *eld) 124 { 125 u64 formats = SNDRV_PCM_FMTBIT_S16; 126 int i; 127 const u8 *sad, *eld_buf = eld; 128 129 sad = drm_eld_sad(eld_buf); 130 if (!sad) 131 goto format_constraint; 132 133 for (i = drm_eld_sad_count(eld_buf); i > 0; i--, sad += 3) { 134 if (sad_format(sad) == 1) { /* AUDIO_CODING_TYPE_LPCM */ 135 136 /* 137 * the controller support 20 and 24 bits in 32 bit 138 * container so we set S32 139 */ 140 if (sad_sample_bits_lpcm(sad) & 0x6) 141 formats |= SNDRV_PCM_FMTBIT_S32; 142 } 143 } 144 145 format_constraint: 146 return snd_pcm_hw_constraint_mask64(runtime, SNDRV_PCM_HW_PARAM_FORMAT, 147 formats); 148 149 } 150 151 /* HDMI ELD routines */ 152 static unsigned int hdac_hdmi_get_eld_data(struct hdac_device *codec, 153 hda_nid_t nid, int byte_index) 154 { 155 unsigned int val; 156 157 val = snd_hdac_codec_read(codec, nid, 0, AC_VERB_GET_HDMI_ELDD, 158 byte_index); 159 160 dev_dbg(&codec->dev, "HDMI: ELD data byte %d: 0x%x\n", 161 byte_index, val); 162 163 return val; 164 } 165 166 static int hdac_hdmi_get_eld_size(struct hdac_device *codec, hda_nid_t nid) 167 { 168 return snd_hdac_codec_read(codec, nid, 0, AC_VERB_GET_HDMI_DIP_SIZE, 169 AC_DIPSIZE_ELD_BUF); 170 } 171 172 /* 173 * This function queries the ELD size and ELD data and fills in the buffer 174 * passed by user 175 */ 176 static int hdac_hdmi_get_eld(struct hdac_device *codec, hda_nid_t nid, 177 unsigned char *buf, int *eld_size) 178 { 179 int i, size, ret = 0; 180 181 /* 182 * ELD size is initialized to zero in caller function. If no errors and 183 * ELD is valid, actual eld_size is assigned. 184 */ 185 186 size = hdac_hdmi_get_eld_size(codec, nid); 187 if (size < ELD_FIXED_BYTES || size > ELD_MAX_SIZE) { 188 dev_err(&codec->dev, "HDMI: invalid ELD buf size %d\n", size); 189 return -ERANGE; 190 } 191 192 /* set ELD buffer */ 193 for (i = 0; i < size; i++) { 194 unsigned int val = hdac_hdmi_get_eld_data(codec, nid, i); 195 /* 196 * Graphics driver might be writing to ELD buffer right now. 197 * Just abort. The caller will repoll after a while. 198 */ 199 if (!(val & AC_ELDD_ELD_VALID)) { 200 dev_err(&codec->dev, 201 "HDMI: invalid ELD data byte %d\n", i); 202 ret = -EINVAL; 203 goto error; 204 } 205 val &= AC_ELDD_ELD_DATA; 206 /* 207 * The first byte cannot be zero. This can happen on some DVI 208 * connections. Some Intel chips may also need some 250ms delay 209 * to return non-zero ELD data, even when the graphics driver 210 * correctly writes ELD content before setting ELD_valid bit. 211 */ 212 if (!val && !i) { 213 dev_err(&codec->dev, "HDMI: 0 ELD data\n"); 214 ret = -EINVAL; 215 goto error; 216 } 217 buf[i] = val; 218 } 219 220 *eld_size = size; 221 error: 222 return ret; 223 } 224 225 static int hdac_hdmi_setup_stream(struct hdac_ext_device *hdac, 226 hda_nid_t cvt_nid, hda_nid_t pin_nid, 227 u32 stream_tag, int format) 228 { 229 unsigned int val; 230 231 dev_dbg(&hdac->hdac.dev, "cvt nid %d pnid %d stream %d format 0x%x\n", 232 cvt_nid, pin_nid, stream_tag, format); 233 234 val = (stream_tag << 4); 235 236 snd_hdac_codec_write(&hdac->hdac, cvt_nid, 0, 237 AC_VERB_SET_CHANNEL_STREAMID, val); 238 snd_hdac_codec_write(&hdac->hdac, cvt_nid, 0, 239 AC_VERB_SET_STREAM_FORMAT, format); 240 241 return 0; 242 } 243 244 static void 245 hdac_hdmi_set_dip_index(struct hdac_ext_device *hdac, hda_nid_t pin_nid, 246 int packet_index, int byte_index) 247 { 248 int val; 249 250 val = (packet_index << 5) | (byte_index & 0x1f); 251 252 snd_hdac_codec_write(&hdac->hdac, pin_nid, 0, 253 AC_VERB_SET_HDMI_DIP_INDEX, val); 254 } 255 256 struct dp_audio_infoframe { 257 u8 type; /* 0x84 */ 258 u8 len; /* 0x1b */ 259 u8 ver; /* 0x11 << 2 */ 260 261 u8 CC02_CT47; /* match with HDMI infoframe from this on */ 262 u8 SS01_SF24; 263 u8 CXT04; 264 u8 CA; 265 u8 LFEPBL01_LSV36_DM_INH7; 266 }; 267 268 static int hdac_hdmi_setup_audio_infoframe(struct hdac_ext_device *hdac, 269 hda_nid_t cvt_nid, hda_nid_t pin_nid) 270 { 271 uint8_t buffer[HDMI_INFOFRAME_HEADER_SIZE + HDMI_AUDIO_INFOFRAME_SIZE]; 272 struct hdmi_audio_infoframe frame; 273 struct dp_audio_infoframe dp_ai; 274 struct hdac_hdmi_priv *hdmi = hdac->private_data; 275 struct hdac_hdmi_pin *pin; 276 u8 *dip; 277 int ret; 278 int i; 279 const u8 *eld_buf; 280 u8 conn_type; 281 int channels = 2; 282 283 list_for_each_entry(pin, &hdmi->pin_list, head) { 284 if (pin->nid == pin_nid) 285 break; 286 } 287 288 eld_buf = pin->eld.eld_buffer; 289 conn_type = drm_eld_get_conn_type(eld_buf); 290 291 /* setup channel count */ 292 snd_hdac_codec_write(&hdac->hdac, cvt_nid, 0, 293 AC_VERB_SET_CVT_CHAN_COUNT, channels - 1); 294 295 switch (conn_type) { 296 case DRM_ELD_CONN_TYPE_HDMI: 297 hdmi_audio_infoframe_init(&frame); 298 299 /* Default stereo for now */ 300 frame.channels = channels; 301 302 ret = hdmi_audio_infoframe_pack(&frame, buffer, sizeof(buffer)); 303 if (ret < 0) 304 return ret; 305 306 break; 307 308 case DRM_ELD_CONN_TYPE_DP: 309 memset(&dp_ai, 0, sizeof(dp_ai)); 310 dp_ai.type = 0x84; 311 dp_ai.len = 0x1b; 312 dp_ai.ver = 0x11 << 2; 313 dp_ai.CC02_CT47 = channels - 1; 314 dp_ai.CA = 0; 315 316 dip = (u8 *)&dp_ai; 317 break; 318 319 default: 320 dev_err(&hdac->hdac.dev, "Invalid connection type: %d\n", 321 conn_type); 322 return -EIO; 323 } 324 325 /* stop infoframe transmission */ 326 hdac_hdmi_set_dip_index(hdac, pin_nid, 0x0, 0x0); 327 snd_hdac_codec_write(&hdac->hdac, pin_nid, 0, 328 AC_VERB_SET_HDMI_DIP_XMIT, AC_DIPXMIT_DISABLE); 329 330 331 /* Fill infoframe. Index auto-incremented */ 332 hdac_hdmi_set_dip_index(hdac, pin_nid, 0x0, 0x0); 333 if (conn_type == DRM_ELD_CONN_TYPE_HDMI) { 334 for (i = 0; i < sizeof(buffer); i++) 335 snd_hdac_codec_write(&hdac->hdac, pin_nid, 0, 336 AC_VERB_SET_HDMI_DIP_DATA, buffer[i]); 337 } else { 338 for (i = 0; i < sizeof(dp_ai); i++) 339 snd_hdac_codec_write(&hdac->hdac, pin_nid, 0, 340 AC_VERB_SET_HDMI_DIP_DATA, dip[i]); 341 } 342 343 /* Start infoframe */ 344 hdac_hdmi_set_dip_index(hdac, pin_nid, 0x0, 0x0); 345 snd_hdac_codec_write(&hdac->hdac, pin_nid, 0, 346 AC_VERB_SET_HDMI_DIP_XMIT, AC_DIPXMIT_BEST); 347 348 return 0; 349 } 350 351 static void hdac_hdmi_set_power_state(struct hdac_ext_device *edev, 352 struct hdac_hdmi_dai_pin_map *dai_map, unsigned int pwr_state) 353 { 354 /* Power up pin widget */ 355 if (!snd_hdac_check_power_state(&edev->hdac, dai_map->pin->nid, 356 pwr_state)) 357 snd_hdac_codec_write(&edev->hdac, dai_map->pin->nid, 0, 358 AC_VERB_SET_POWER_STATE, pwr_state); 359 360 /* Power up converter */ 361 if (!snd_hdac_check_power_state(&edev->hdac, dai_map->cvt->nid, 362 pwr_state)) 363 snd_hdac_codec_write(&edev->hdac, dai_map->cvt->nid, 0, 364 AC_VERB_SET_POWER_STATE, pwr_state); 365 } 366 367 static int hdac_hdmi_playback_prepare(struct snd_pcm_substream *substream, 368 struct snd_soc_dai *dai) 369 { 370 struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai); 371 struct hdac_hdmi_priv *hdmi = hdac->private_data; 372 struct hdac_hdmi_dai_pin_map *dai_map; 373 struct hdac_ext_dma_params *dd; 374 int ret; 375 376 dai_map = &hdmi->dai_map[dai->id]; 377 378 dd = (struct hdac_ext_dma_params *)snd_soc_dai_get_dma_data(dai, substream); 379 dev_dbg(&hdac->hdac.dev, "stream tag from cpu dai %d format in cvt 0x%x\n", 380 dd->stream_tag, dd->format); 381 382 ret = hdac_hdmi_setup_audio_infoframe(hdac, dai_map->cvt->nid, 383 dai_map->pin->nid); 384 if (ret < 0) 385 return ret; 386 387 return hdac_hdmi_setup_stream(hdac, dai_map->cvt->nid, 388 dai_map->pin->nid, dd->stream_tag, dd->format); 389 } 390 391 static int hdac_hdmi_set_hw_params(struct snd_pcm_substream *substream, 392 struct snd_pcm_hw_params *hparams, struct snd_soc_dai *dai) 393 { 394 struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai); 395 struct hdac_hdmi_priv *hdmi = hdac->private_data; 396 struct hdac_hdmi_dai_pin_map *dai_map; 397 struct hdac_hdmi_pin *pin; 398 struct hdac_ext_dma_params *dd; 399 400 dai_map = &hdmi->dai_map[dai->id]; 401 pin = dai_map->pin; 402 403 if (!pin) 404 return -ENODEV; 405 406 if ((!pin->eld.monitor_present) || (!pin->eld.eld_valid)) { 407 dev_err(&hdac->hdac.dev, "device is not configured for this pin: %d\n", 408 pin->nid); 409 return -ENODEV; 410 } 411 412 dd = snd_soc_dai_get_dma_data(dai, substream); 413 if (!dd) { 414 dd = kzalloc(sizeof(*dd), GFP_KERNEL); 415 if (!dd) 416 return -ENOMEM; 417 } 418 419 dd->format = snd_hdac_calc_stream_format(params_rate(hparams), 420 params_channels(hparams), params_format(hparams), 421 24, 0); 422 423 snd_soc_dai_set_dma_data(dai, substream, (void *)dd); 424 425 return 0; 426 } 427 428 static int hdac_hdmi_playback_cleanup(struct snd_pcm_substream *substream, 429 struct snd_soc_dai *dai) 430 { 431 struct hdac_ext_device *edev = snd_soc_dai_get_drvdata(dai); 432 struct hdac_ext_dma_params *dd; 433 struct hdac_hdmi_priv *hdmi = edev->private_data; 434 struct hdac_hdmi_dai_pin_map *dai_map; 435 436 dai_map = &hdmi->dai_map[dai->id]; 437 438 dd = (struct hdac_ext_dma_params *)snd_soc_dai_get_dma_data(dai, substream); 439 440 if (dd) { 441 snd_soc_dai_set_dma_data(dai, substream, NULL); 442 kfree(dd); 443 } 444 445 return 0; 446 } 447 448 static void hdac_hdmi_enable_cvt(struct hdac_ext_device *edev, 449 struct hdac_hdmi_dai_pin_map *dai_map) 450 { 451 /* Enable transmission */ 452 snd_hdac_codec_write(&edev->hdac, dai_map->cvt->nid, 0, 453 AC_VERB_SET_DIGI_CONVERT_1, 1); 454 455 /* Category Code (CC) to zero */ 456 snd_hdac_codec_write(&edev->hdac, dai_map->cvt->nid, 0, 457 AC_VERB_SET_DIGI_CONVERT_2, 0); 458 } 459 460 static int hdac_hdmi_enable_pin(struct hdac_ext_device *hdac, 461 struct hdac_hdmi_dai_pin_map *dai_map) 462 { 463 int mux_idx; 464 struct hdac_hdmi_pin *pin = dai_map->pin; 465 466 for (mux_idx = 0; mux_idx < pin->num_mux_nids; mux_idx++) { 467 if (pin->mux_nids[mux_idx] == dai_map->cvt->nid) { 468 snd_hdac_codec_write(&hdac->hdac, pin->nid, 0, 469 AC_VERB_SET_CONNECT_SEL, mux_idx); 470 break; 471 } 472 } 473 474 if (mux_idx == pin->num_mux_nids) 475 return -EIO; 476 477 /* Enable out path for this pin widget */ 478 snd_hdac_codec_write(&hdac->hdac, pin->nid, 0, 479 AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); 480 481 hdac_hdmi_set_power_state(hdac, dai_map, AC_PWRST_D0); 482 483 snd_hdac_codec_write(&hdac->hdac, pin->nid, 0, 484 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE); 485 486 return 0; 487 } 488 489 static int hdac_hdmi_query_pin_connlist(struct hdac_ext_device *hdac, 490 struct hdac_hdmi_pin *pin) 491 { 492 if (!(get_wcaps(&hdac->hdac, pin->nid) & AC_WCAP_CONN_LIST)) { 493 dev_warn(&hdac->hdac.dev, 494 "HDMI: pin %d wcaps %#x does not support connection list\n", 495 pin->nid, get_wcaps(&hdac->hdac, pin->nid)); 496 return -EINVAL; 497 } 498 499 pin->num_mux_nids = snd_hdac_get_connections(&hdac->hdac, pin->nid, 500 pin->mux_nids, HDA_MAX_CONNECTIONS); 501 if (pin->num_mux_nids == 0) 502 dev_warn(&hdac->hdac.dev, "No connections found for pin: %d\n", 503 pin->nid); 504 505 dev_dbg(&hdac->hdac.dev, "num_mux_nids %d for pin: %d\n", 506 pin->num_mux_nids, pin->nid); 507 508 return pin->num_mux_nids; 509 } 510 511 /* 512 * Query pcm list and return pin widget to which stream is routed. 513 * 514 * Also query connection list of the pin, to validate the cvt to pin map. 515 * 516 * Same stream rendering to multiple pins simultaneously can be done 517 * possibly, but not supported for now in driver. So return the first pin 518 * connected. 519 */ 520 static struct hdac_hdmi_pin *hdac_hdmi_get_pin_from_cvt( 521 struct hdac_ext_device *edev, 522 struct hdac_hdmi_priv *hdmi, 523 struct hdac_hdmi_cvt *cvt) 524 { 525 struct hdac_hdmi_pcm *pcm; 526 struct hdac_hdmi_pin *pin = NULL; 527 int ret, i; 528 529 list_for_each_entry(pcm, &hdmi->pcm_list, head) { 530 if (pcm->cvt == cvt) { 531 pin = pcm->pin; 532 break; 533 } 534 } 535 536 if (pin) { 537 ret = hdac_hdmi_query_pin_connlist(edev, pin); 538 if (ret < 0) 539 return NULL; 540 541 for (i = 0; i < pin->num_mux_nids; i++) { 542 if (pin->mux_nids[i] == cvt->nid) 543 return pin; 544 } 545 } 546 547 return NULL; 548 } 549 550 /* 551 * This tries to get a valid pin and set the HW constraints based on the 552 * ELD. Even if a valid pin is not found return success so that device open 553 * doesn't fail. 554 */ 555 static int hdac_hdmi_pcm_open(struct snd_pcm_substream *substream, 556 struct snd_soc_dai *dai) 557 { 558 struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai); 559 struct hdac_hdmi_priv *hdmi = hdac->private_data; 560 struct hdac_hdmi_dai_pin_map *dai_map; 561 struct hdac_hdmi_cvt *cvt; 562 struct hdac_hdmi_pin *pin; 563 int ret; 564 565 dai_map = &hdmi->dai_map[dai->id]; 566 567 cvt = dai_map->cvt; 568 pin = hdac_hdmi_get_pin_from_cvt(hdac, hdmi, cvt); 569 570 /* 571 * To make PA and other userland happy. 572 * userland scans devices so returning error does not help. 573 */ 574 if (!pin) 575 return 0; 576 577 if ((!pin->eld.monitor_present) || 578 (!pin->eld.eld_valid)) { 579 580 dev_warn(&hdac->hdac.dev, 581 "Failed: montior present? %d ELD valid?: %d for pin: %d\n", 582 pin->eld.monitor_present, pin->eld.eld_valid, pin->nid); 583 584 return 0; 585 } 586 587 dai_map->pin = pin; 588 589 hdac_hdmi_enable_cvt(hdac, dai_map); 590 ret = hdac_hdmi_enable_pin(hdac, dai_map); 591 if (ret < 0) 592 return ret; 593 594 ret = hdac_hdmi_eld_limit_formats(substream->runtime, 595 pin->eld.eld_buffer); 596 if (ret < 0) 597 return ret; 598 599 return snd_pcm_hw_constraint_eld(substream->runtime, 600 pin->eld.eld_buffer); 601 } 602 603 static int hdac_hdmi_trigger(struct snd_pcm_substream *substream, int cmd, 604 struct snd_soc_dai *dai) 605 { 606 struct hdac_hdmi_dai_pin_map *dai_map; 607 struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai); 608 struct hdac_hdmi_priv *hdmi = hdac->private_data; 609 int ret; 610 611 dai_map = &hdmi->dai_map[dai->id]; 612 if (cmd == SNDRV_PCM_TRIGGER_RESUME) { 613 ret = hdac_hdmi_enable_pin(hdac, dai_map); 614 if (ret < 0) 615 return ret; 616 617 return hdac_hdmi_playback_prepare(substream, dai); 618 } 619 620 return 0; 621 } 622 623 static void hdac_hdmi_pcm_close(struct snd_pcm_substream *substream, 624 struct snd_soc_dai *dai) 625 { 626 struct hdac_ext_device *hdac = snd_soc_dai_get_drvdata(dai); 627 struct hdac_hdmi_priv *hdmi = hdac->private_data; 628 struct hdac_hdmi_dai_pin_map *dai_map; 629 630 dai_map = &hdmi->dai_map[dai->id]; 631 632 if (dai_map->pin) { 633 snd_hdac_codec_write(&hdac->hdac, dai_map->cvt->nid, 0, 634 AC_VERB_SET_CHANNEL_STREAMID, 0); 635 snd_hdac_codec_write(&hdac->hdac, dai_map->cvt->nid, 0, 636 AC_VERB_SET_STREAM_FORMAT, 0); 637 638 hdac_hdmi_set_power_state(hdac, dai_map, AC_PWRST_D3); 639 640 snd_hdac_codec_write(&hdac->hdac, dai_map->pin->nid, 0, 641 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); 642 643 dai_map->pin = NULL; 644 } 645 } 646 647 static int 648 hdac_hdmi_query_cvt_params(struct hdac_device *hdac, struct hdac_hdmi_cvt *cvt) 649 { 650 int err; 651 652 /* Only stereo supported as of now */ 653 cvt->params.channels_min = cvt->params.channels_max = 2; 654 655 err = snd_hdac_query_supported_pcm(hdac, cvt->nid, 656 &cvt->params.rates, 657 &cvt->params.formats, 658 &cvt->params.maxbps); 659 if (err < 0) 660 dev_err(&hdac->dev, 661 "Failed to query pcm params for nid %d: %d\n", 662 cvt->nid, err); 663 664 return err; 665 } 666 667 static int hdac_hdmi_fill_widget_info(struct device *dev, 668 struct snd_soc_dapm_widget *w, 669 enum snd_soc_dapm_type id, void *priv, 670 const char *wname, const char *stream, 671 struct snd_kcontrol_new *wc, int numkc) 672 { 673 w->id = id; 674 w->name = devm_kstrdup(dev, wname, GFP_KERNEL); 675 if (!w->name) 676 return -ENOMEM; 677 678 w->sname = stream; 679 w->reg = SND_SOC_NOPM; 680 w->shift = 0; 681 w->kcontrol_news = wc; 682 w->num_kcontrols = numkc; 683 w->priv = priv; 684 685 return 0; 686 } 687 688 static void hdac_hdmi_fill_route(struct snd_soc_dapm_route *route, 689 const char *sink, const char *control, const char *src, 690 int (*handler)(struct snd_soc_dapm_widget *src, 691 struct snd_soc_dapm_widget *sink)) 692 { 693 route->sink = sink; 694 route->source = src; 695 route->control = control; 696 route->connected = handler; 697 } 698 699 static struct hdac_hdmi_pcm *hdac_hdmi_get_pcm(struct hdac_ext_device *edev, 700 struct hdac_hdmi_pin *pin) 701 { 702 struct hdac_hdmi_priv *hdmi = edev->private_data; 703 struct hdac_hdmi_pcm *pcm = NULL; 704 705 list_for_each_entry(pcm, &hdmi->pcm_list, head) { 706 if (pcm->pin == pin) 707 return pcm; 708 } 709 710 return NULL; 711 } 712 713 /* 714 * Based on user selection, map the PINs with the PCMs. 715 */ 716 static int hdac_hdmi_set_pin_mux(struct snd_kcontrol *kcontrol, 717 struct snd_ctl_elem_value *ucontrol) 718 { 719 int ret; 720 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 721 struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol); 722 struct snd_soc_dapm_context *dapm = w->dapm; 723 struct hdac_hdmi_pin *pin = w->priv; 724 struct hdac_ext_device *edev = to_hda_ext_device(dapm->dev); 725 struct hdac_hdmi_priv *hdmi = edev->private_data; 726 struct hdac_hdmi_pcm *pcm = NULL; 727 const char *cvt_name = e->texts[ucontrol->value.enumerated.item[0]]; 728 729 ret = snd_soc_dapm_put_enum_double(kcontrol, ucontrol); 730 if (ret < 0) 731 return ret; 732 733 mutex_lock(&hdmi->pin_mutex); 734 list_for_each_entry(pcm, &hdmi->pcm_list, head) { 735 if (pcm->pin == pin) 736 pcm->pin = NULL; 737 738 /* 739 * Jack status is not reported during device probe as the 740 * PCMs are not registered by then. So report it here. 741 */ 742 if (!strcmp(cvt_name, pcm->cvt->name) && !pcm->pin) { 743 pcm->pin = pin; 744 if (pin->eld.monitor_present && pin->eld.eld_valid) { 745 dev_dbg(&edev->hdac.dev, 746 "jack report for pcm=%d\n", 747 pcm->pcm_id); 748 749 snd_jack_report(pcm->jack, SND_JACK_AVOUT); 750 } 751 mutex_unlock(&hdmi->pin_mutex); 752 return ret; 753 } 754 } 755 mutex_unlock(&hdmi->pin_mutex); 756 757 return ret; 758 } 759 760 /* 761 * Ideally the Mux inputs should be based on the num_muxs enumerated, but 762 * the display driver seem to be programming the connection list for the pin 763 * widget runtime. 764 * 765 * So programming all the possible inputs for the mux, the user has to take 766 * care of selecting the right one and leaving all other inputs selected to 767 * "NONE" 768 */ 769 static int hdac_hdmi_create_pin_muxs(struct hdac_ext_device *edev, 770 struct hdac_hdmi_pin *pin, 771 struct snd_soc_dapm_widget *widget, 772 const char *widget_name) 773 { 774 struct hdac_hdmi_priv *hdmi = edev->private_data; 775 struct snd_kcontrol_new *kc; 776 struct hdac_hdmi_cvt *cvt; 777 struct soc_enum *se; 778 char kc_name[NAME_SIZE]; 779 char mux_items[NAME_SIZE]; 780 /* To hold inputs to the Pin mux */ 781 char *items[HDA_MAX_CONNECTIONS]; 782 int i = 0; 783 int num_items = hdmi->num_cvt + 1; 784 785 kc = devm_kzalloc(&edev->hdac.dev, sizeof(*kc), GFP_KERNEL); 786 if (!kc) 787 return -ENOMEM; 788 789 se = devm_kzalloc(&edev->hdac.dev, sizeof(*se), GFP_KERNEL); 790 if (!se) 791 return -ENOMEM; 792 793 sprintf(kc_name, "Pin %d Input", pin->nid); 794 kc->name = devm_kstrdup(&edev->hdac.dev, kc_name, GFP_KERNEL); 795 if (!kc->name) 796 return -ENOMEM; 797 798 kc->private_value = (long)se; 799 kc->iface = SNDRV_CTL_ELEM_IFACE_MIXER; 800 kc->access = 0; 801 kc->info = snd_soc_info_enum_double; 802 kc->put = hdac_hdmi_set_pin_mux; 803 kc->get = snd_soc_dapm_get_enum_double; 804 805 se->reg = SND_SOC_NOPM; 806 807 /* enum texts: ["NONE", "cvt #", "cvt #", ...] */ 808 se->items = num_items; 809 se->mask = roundup_pow_of_two(se->items) - 1; 810 811 sprintf(mux_items, "NONE"); 812 items[i] = devm_kstrdup(&edev->hdac.dev, mux_items, GFP_KERNEL); 813 if (!items[i]) 814 return -ENOMEM; 815 816 list_for_each_entry(cvt, &hdmi->cvt_list, head) { 817 i++; 818 sprintf(mux_items, "cvt %d", cvt->nid); 819 items[i] = devm_kstrdup(&edev->hdac.dev, mux_items, GFP_KERNEL); 820 if (!items[i]) 821 return -ENOMEM; 822 } 823 824 se->texts = devm_kmemdup(&edev->hdac.dev, items, 825 (num_items * sizeof(char *)), GFP_KERNEL); 826 if (!se->texts) 827 return -ENOMEM; 828 829 return hdac_hdmi_fill_widget_info(&edev->hdac.dev, widget, 830 snd_soc_dapm_mux, pin, widget_name, NULL, kc, 1); 831 } 832 833 /* Add cvt <- input <- mux route map */ 834 static void hdac_hdmi_add_pinmux_cvt_route(struct hdac_ext_device *edev, 835 struct snd_soc_dapm_widget *widgets, 836 struct snd_soc_dapm_route *route, int rindex) 837 { 838 struct hdac_hdmi_priv *hdmi = edev->private_data; 839 const struct snd_kcontrol_new *kc; 840 struct soc_enum *se; 841 int mux_index = hdmi->num_cvt + hdmi->num_pin; 842 int i, j; 843 844 for (i = 0; i < hdmi->num_pin; i++) { 845 kc = widgets[mux_index].kcontrol_news; 846 se = (struct soc_enum *)kc->private_value; 847 for (j = 0; j < hdmi->num_cvt; j++) { 848 hdac_hdmi_fill_route(&route[rindex], 849 widgets[mux_index].name, 850 se->texts[j + 1], 851 widgets[j].name, NULL); 852 853 rindex++; 854 } 855 856 mux_index++; 857 } 858 } 859 860 /* 861 * Widgets are added in the below sequence 862 * Converter widgets for num converters enumerated 863 * Pin widgets for num pins enumerated 864 * Pin mux widgets to represent connenction list of pin widget 865 * 866 * Total widgets elements = num_cvt + num_pin + num_pin; 867 * 868 * Routes are added as below: 869 * pin mux -> pin (based on num_pins) 870 * cvt -> "Input sel control" -> pin_mux 871 * 872 * Total route elements: 873 * num_pins + (pin_muxes * num_cvt) 874 */ 875 static int create_fill_widget_route_map(struct snd_soc_dapm_context *dapm) 876 { 877 struct snd_soc_dapm_widget *widgets; 878 struct snd_soc_dapm_route *route; 879 struct hdac_ext_device *edev = to_hda_ext_device(dapm->dev); 880 struct hdac_hdmi_priv *hdmi = edev->private_data; 881 struct snd_soc_dai_driver *dai_drv = dapm->component->dai_drv; 882 char widget_name[NAME_SIZE]; 883 struct hdac_hdmi_cvt *cvt; 884 struct hdac_hdmi_pin *pin; 885 int ret, i = 0, num_routes = 0; 886 887 if (list_empty(&hdmi->cvt_list) || list_empty(&hdmi->pin_list)) 888 return -EINVAL; 889 890 widgets = devm_kzalloc(dapm->dev, 891 (sizeof(*widgets) * ((2 * hdmi->num_pin) + hdmi->num_cvt)), 892 GFP_KERNEL); 893 894 if (!widgets) 895 return -ENOMEM; 896 897 /* DAPM widgets to represent each converter widget */ 898 list_for_each_entry(cvt, &hdmi->cvt_list, head) { 899 sprintf(widget_name, "Converter %d", cvt->nid); 900 ret = hdac_hdmi_fill_widget_info(dapm->dev, &widgets[i], 901 snd_soc_dapm_aif_in, &cvt->nid, 902 widget_name, dai_drv[i].playback.stream_name, NULL, 0); 903 if (ret < 0) 904 return ret; 905 i++; 906 } 907 908 list_for_each_entry(pin, &hdmi->pin_list, head) { 909 sprintf(widget_name, "hif%d Output", pin->nid); 910 ret = hdac_hdmi_fill_widget_info(dapm->dev, &widgets[i], 911 snd_soc_dapm_output, &pin->nid, 912 widget_name, NULL, NULL, 0); 913 if (ret < 0) 914 return ret; 915 i++; 916 } 917 918 /* DAPM widgets to represent the connection list to pin widget */ 919 list_for_each_entry(pin, &hdmi->pin_list, head) { 920 sprintf(widget_name, "Pin %d Mux", pin->nid); 921 ret = hdac_hdmi_create_pin_muxs(edev, pin, &widgets[i], 922 widget_name); 923 if (ret < 0) 924 return ret; 925 i++; 926 927 /* For cvt to pin_mux mapping */ 928 num_routes += hdmi->num_cvt; 929 930 /* For pin_mux to pin mapping */ 931 num_routes++; 932 } 933 934 route = devm_kzalloc(dapm->dev, (sizeof(*route) * num_routes), 935 GFP_KERNEL); 936 if (!route) 937 return -ENOMEM; 938 939 i = 0; 940 /* Add pin <- NULL <- mux route map */ 941 list_for_each_entry(pin, &hdmi->pin_list, head) { 942 int sink_index = i + hdmi->num_cvt; 943 int src_index = sink_index + hdmi->num_pin; 944 945 hdac_hdmi_fill_route(&route[i], 946 widgets[sink_index].name, NULL, 947 widgets[src_index].name, NULL); 948 i++; 949 950 } 951 952 hdac_hdmi_add_pinmux_cvt_route(edev, widgets, route, i); 953 954 snd_soc_dapm_new_controls(dapm, widgets, 955 ((2 * hdmi->num_pin) + hdmi->num_cvt)); 956 957 snd_soc_dapm_add_routes(dapm, route, num_routes); 958 snd_soc_dapm_new_widgets(dapm->card); 959 960 return 0; 961 962 } 963 964 static int hdac_hdmi_init_dai_map(struct hdac_ext_device *edev) 965 { 966 struct hdac_hdmi_priv *hdmi = edev->private_data; 967 struct hdac_hdmi_dai_pin_map *dai_map; 968 struct hdac_hdmi_cvt *cvt; 969 int dai_id = 0; 970 971 if (list_empty(&hdmi->cvt_list)) 972 return -EINVAL; 973 974 list_for_each_entry(cvt, &hdmi->cvt_list, head) { 975 dai_map = &hdmi->dai_map[dai_id]; 976 dai_map->dai_id = dai_id; 977 dai_map->cvt = cvt; 978 979 dai_id++; 980 981 if (dai_id == HDA_MAX_CVTS) { 982 dev_warn(&edev->hdac.dev, 983 "Max dais supported: %d\n", dai_id); 984 break; 985 } 986 } 987 988 return 0; 989 } 990 991 static int hdac_hdmi_add_cvt(struct hdac_ext_device *edev, hda_nid_t nid) 992 { 993 struct hdac_hdmi_priv *hdmi = edev->private_data; 994 struct hdac_hdmi_cvt *cvt; 995 char name[NAME_SIZE]; 996 997 cvt = kzalloc(sizeof(*cvt), GFP_KERNEL); 998 if (!cvt) 999 return -ENOMEM; 1000 1001 cvt->nid = nid; 1002 sprintf(name, "cvt %d", cvt->nid); 1003 cvt->name = kstrdup(name, GFP_KERNEL); 1004 1005 list_add_tail(&cvt->head, &hdmi->cvt_list); 1006 hdmi->num_cvt++; 1007 1008 return hdac_hdmi_query_cvt_params(&edev->hdac, cvt); 1009 } 1010 1011 static void hdac_hdmi_present_sense(struct hdac_hdmi_pin *pin, int repoll) 1012 { 1013 struct hdac_ext_device *edev = pin->edev; 1014 struct hdac_hdmi_priv *hdmi = edev->private_data; 1015 struct hdac_hdmi_pcm *pcm; 1016 int val; 1017 1018 pin->repoll_count = repoll; 1019 1020 pm_runtime_get_sync(&edev->hdac.dev); 1021 val = snd_hdac_codec_read(&edev->hdac, pin->nid, 0, 1022 AC_VERB_GET_PIN_SENSE, 0); 1023 1024 dev_dbg(&edev->hdac.dev, "Pin sense val %x for pin: %d\n", 1025 val, pin->nid); 1026 1027 1028 mutex_lock(&hdmi->pin_mutex); 1029 pin->eld.monitor_present = !!(val & AC_PINSENSE_PRESENCE); 1030 pin->eld.eld_valid = !!(val & AC_PINSENSE_ELDV); 1031 1032 pcm = hdac_hdmi_get_pcm(edev, pin); 1033 1034 if (!pin->eld.monitor_present || !pin->eld.eld_valid) { 1035 1036 dev_dbg(&edev->hdac.dev, "%s: disconnect for pin %d\n", 1037 __func__, pin->nid); 1038 1039 /* 1040 * PCMs are not registered during device probe, so don't 1041 * report jack here. It will be done in usermode mux 1042 * control select. 1043 */ 1044 if (pcm) { 1045 dev_dbg(&edev->hdac.dev, 1046 "jack report for pcm=%d\n", pcm->pcm_id); 1047 1048 snd_jack_report(pcm->jack, 0); 1049 } 1050 1051 mutex_unlock(&hdmi->pin_mutex); 1052 goto put_hdac_device; 1053 } 1054 1055 if (pin->eld.monitor_present && pin->eld.eld_valid) { 1056 /* TODO: use i915 component for reading ELD later */ 1057 if (hdac_hdmi_get_eld(&edev->hdac, pin->nid, 1058 pin->eld.eld_buffer, 1059 &pin->eld.eld_size) == 0) { 1060 1061 if (pcm) { 1062 dev_dbg(&edev->hdac.dev, 1063 "jack report for pcm=%d\n", 1064 pcm->pcm_id); 1065 1066 snd_jack_report(pcm->jack, SND_JACK_AVOUT); 1067 } 1068 1069 print_hex_dump_bytes("ELD: ", DUMP_PREFIX_OFFSET, 1070 pin->eld.eld_buffer, pin->eld.eld_size); 1071 } else { 1072 pin->eld.monitor_present = false; 1073 pin->eld.eld_valid = false; 1074 1075 if (pcm) { 1076 dev_dbg(&edev->hdac.dev, 1077 "jack report for pcm=%d\n", 1078 pcm->pcm_id); 1079 1080 snd_jack_report(pcm->jack, 0); 1081 } 1082 } 1083 } 1084 1085 mutex_unlock(&hdmi->pin_mutex); 1086 1087 /* 1088 * Sometimes the pin_sense may present invalid monitor 1089 * present and eld_valid. If ELD data is not valid, loop few 1090 * more times to get correct pin sense and valid ELD. 1091 */ 1092 if ((!pin->eld.monitor_present || !pin->eld.eld_valid) && repoll) 1093 schedule_delayed_work(&pin->work, msecs_to_jiffies(300)); 1094 1095 put_hdac_device: 1096 pm_runtime_put_sync(&edev->hdac.dev); 1097 } 1098 1099 static void hdac_hdmi_repoll_eld(struct work_struct *work) 1100 { 1101 struct hdac_hdmi_pin *pin = 1102 container_of(to_delayed_work(work), struct hdac_hdmi_pin, work); 1103 1104 /* picked from legacy HDA driver */ 1105 if (pin->repoll_count++ > 6) 1106 pin->repoll_count = 0; 1107 1108 hdac_hdmi_present_sense(pin, pin->repoll_count); 1109 } 1110 1111 static int hdac_hdmi_add_pin(struct hdac_ext_device *edev, hda_nid_t nid) 1112 { 1113 struct hdac_hdmi_priv *hdmi = edev->private_data; 1114 struct hdac_hdmi_pin *pin; 1115 1116 pin = kzalloc(sizeof(*pin), GFP_KERNEL); 1117 if (!pin) 1118 return -ENOMEM; 1119 1120 pin->nid = nid; 1121 1122 list_add_tail(&pin->head, &hdmi->pin_list); 1123 hdmi->num_pin++; 1124 1125 pin->edev = edev; 1126 INIT_DELAYED_WORK(&pin->work, hdac_hdmi_repoll_eld); 1127 1128 return 0; 1129 } 1130 1131 #define INTEL_VENDOR_NID 0x08 1132 #define INTEL_GET_VENDOR_VERB 0xf81 1133 #define INTEL_SET_VENDOR_VERB 0x781 1134 #define INTEL_EN_DP12 0x02 /* enable DP 1.2 features */ 1135 #define INTEL_EN_ALL_PIN_CVTS 0x01 /* enable 2nd & 3rd pins and convertors */ 1136 1137 static void hdac_hdmi_skl_enable_all_pins(struct hdac_device *hdac) 1138 { 1139 unsigned int vendor_param; 1140 1141 vendor_param = snd_hdac_codec_read(hdac, INTEL_VENDOR_NID, 0, 1142 INTEL_GET_VENDOR_VERB, 0); 1143 if (vendor_param == -1 || vendor_param & INTEL_EN_ALL_PIN_CVTS) 1144 return; 1145 1146 vendor_param |= INTEL_EN_ALL_PIN_CVTS; 1147 vendor_param = snd_hdac_codec_read(hdac, INTEL_VENDOR_NID, 0, 1148 INTEL_SET_VENDOR_VERB, vendor_param); 1149 if (vendor_param == -1) 1150 return; 1151 } 1152 1153 static void hdac_hdmi_skl_enable_dp12(struct hdac_device *hdac) 1154 { 1155 unsigned int vendor_param; 1156 1157 vendor_param = snd_hdac_codec_read(hdac, INTEL_VENDOR_NID, 0, 1158 INTEL_GET_VENDOR_VERB, 0); 1159 if (vendor_param == -1 || vendor_param & INTEL_EN_DP12) 1160 return; 1161 1162 /* enable DP1.2 mode */ 1163 vendor_param |= INTEL_EN_DP12; 1164 vendor_param = snd_hdac_codec_read(hdac, INTEL_VENDOR_NID, 0, 1165 INTEL_SET_VENDOR_VERB, vendor_param); 1166 if (vendor_param == -1) 1167 return; 1168 1169 } 1170 1171 static struct snd_soc_dai_ops hdmi_dai_ops = { 1172 .startup = hdac_hdmi_pcm_open, 1173 .shutdown = hdac_hdmi_pcm_close, 1174 .hw_params = hdac_hdmi_set_hw_params, 1175 .prepare = hdac_hdmi_playback_prepare, 1176 .trigger = hdac_hdmi_trigger, 1177 .hw_free = hdac_hdmi_playback_cleanup, 1178 }; 1179 1180 /* 1181 * Each converter can support a stream independently. So a dai is created 1182 * based on the number of converter queried. 1183 */ 1184 static int hdac_hdmi_create_dais(struct hdac_device *hdac, 1185 struct snd_soc_dai_driver **dais, 1186 struct hdac_hdmi_priv *hdmi, int num_dais) 1187 { 1188 struct snd_soc_dai_driver *hdmi_dais; 1189 struct hdac_hdmi_cvt *cvt; 1190 char name[NAME_SIZE], dai_name[NAME_SIZE]; 1191 int i = 0; 1192 u32 rates, bps; 1193 unsigned int rate_max = 384000, rate_min = 8000; 1194 u64 formats; 1195 int ret; 1196 1197 hdmi_dais = devm_kzalloc(&hdac->dev, 1198 (sizeof(*hdmi_dais) * num_dais), 1199 GFP_KERNEL); 1200 if (!hdmi_dais) 1201 return -ENOMEM; 1202 1203 list_for_each_entry(cvt, &hdmi->cvt_list, head) { 1204 ret = snd_hdac_query_supported_pcm(hdac, cvt->nid, 1205 &rates, &formats, &bps); 1206 if (ret) 1207 return ret; 1208 1209 sprintf(dai_name, "intel-hdmi-hifi%d", i+1); 1210 hdmi_dais[i].name = devm_kstrdup(&hdac->dev, 1211 dai_name, GFP_KERNEL); 1212 1213 if (!hdmi_dais[i].name) 1214 return -ENOMEM; 1215 1216 snprintf(name, sizeof(name), "hifi%d", i+1); 1217 hdmi_dais[i].playback.stream_name = 1218 devm_kstrdup(&hdac->dev, name, GFP_KERNEL); 1219 if (!hdmi_dais[i].playback.stream_name) 1220 return -ENOMEM; 1221 1222 /* 1223 * Set caps based on capability queried from the converter. 1224 * It will be constrained runtime based on ELD queried. 1225 */ 1226 hdmi_dais[i].playback.formats = formats; 1227 hdmi_dais[i].playback.rates = rates; 1228 hdmi_dais[i].playback.rate_max = rate_max; 1229 hdmi_dais[i].playback.rate_min = rate_min; 1230 hdmi_dais[i].playback.channels_min = 2; 1231 hdmi_dais[i].playback.channels_max = 2; 1232 hdmi_dais[i].ops = &hdmi_dai_ops; 1233 1234 i++; 1235 } 1236 1237 *dais = hdmi_dais; 1238 1239 return 0; 1240 } 1241 1242 /* 1243 * Parse all nodes and store the cvt/pin nids in array 1244 * Add one time initialization for pin and cvt widgets 1245 */ 1246 static int hdac_hdmi_parse_and_map_nid(struct hdac_ext_device *edev, 1247 struct snd_soc_dai_driver **dais, int *num_dais) 1248 { 1249 hda_nid_t nid; 1250 int i, num_nodes; 1251 struct hdac_device *hdac = &edev->hdac; 1252 struct hdac_hdmi_priv *hdmi = edev->private_data; 1253 int ret; 1254 1255 hdac_hdmi_skl_enable_all_pins(hdac); 1256 hdac_hdmi_skl_enable_dp12(hdac); 1257 1258 num_nodes = snd_hdac_get_sub_nodes(hdac, hdac->afg, &nid); 1259 if (!nid || num_nodes <= 0) { 1260 dev_warn(&hdac->dev, "HDMI: failed to get afg sub nodes\n"); 1261 return -EINVAL; 1262 } 1263 1264 hdac->num_nodes = num_nodes; 1265 hdac->start_nid = nid; 1266 1267 for (i = 0; i < hdac->num_nodes; i++, nid++) { 1268 unsigned int caps; 1269 unsigned int type; 1270 1271 caps = get_wcaps(hdac, nid); 1272 type = get_wcaps_type(caps); 1273 1274 if (!(caps & AC_WCAP_DIGITAL)) 1275 continue; 1276 1277 switch (type) { 1278 1279 case AC_WID_AUD_OUT: 1280 ret = hdac_hdmi_add_cvt(edev, nid); 1281 if (ret < 0) 1282 return ret; 1283 break; 1284 1285 case AC_WID_PIN: 1286 ret = hdac_hdmi_add_pin(edev, nid); 1287 if (ret < 0) 1288 return ret; 1289 break; 1290 } 1291 } 1292 1293 hdac->end_nid = nid; 1294 1295 if (!hdmi->num_pin || !hdmi->num_cvt) 1296 return -EIO; 1297 1298 ret = hdac_hdmi_create_dais(hdac, dais, hdmi, hdmi->num_cvt); 1299 if (ret) { 1300 dev_err(&hdac->dev, "Failed to create dais with err: %d\n", 1301 ret); 1302 return ret; 1303 } 1304 1305 *num_dais = hdmi->num_cvt; 1306 1307 return hdac_hdmi_init_dai_map(edev); 1308 } 1309 1310 static void hdac_hdmi_eld_notify_cb(void *aptr, int port) 1311 { 1312 struct hdac_ext_device *edev = aptr; 1313 struct hdac_hdmi_priv *hdmi = edev->private_data; 1314 struct hdac_hdmi_pin *pin; 1315 struct snd_soc_codec *codec = edev->scodec; 1316 1317 /* Don't know how this mapping is derived */ 1318 hda_nid_t pin_nid = port + 0x04; 1319 1320 dev_dbg(&edev->hdac.dev, "%s: for pin: %d\n", __func__, pin_nid); 1321 1322 /* 1323 * skip notification during system suspend (but not in runtime PM); 1324 * the state will be updated at resume. Also since the ELD and 1325 * connection states are updated in anyway at the end of the resume, 1326 * we can skip it when received during PM process. 1327 */ 1328 if (snd_power_get_state(codec->component.card->snd_card) != 1329 SNDRV_CTL_POWER_D0) 1330 return; 1331 1332 if (atomic_read(&edev->hdac.in_pm)) 1333 return; 1334 1335 list_for_each_entry(pin, &hdmi->pin_list, head) { 1336 if (pin->nid == pin_nid) 1337 hdac_hdmi_present_sense(pin, 1); 1338 } 1339 } 1340 1341 static struct i915_audio_component_audio_ops aops = { 1342 .pin_eld_notify = hdac_hdmi_eld_notify_cb, 1343 }; 1344 1345 int hdac_hdmi_jack_init(struct snd_soc_dai *dai, int device) 1346 { 1347 char jack_name[NAME_SIZE]; 1348 struct snd_soc_codec *codec = dai->codec; 1349 struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec); 1350 struct snd_soc_dapm_context *dapm = 1351 snd_soc_component_get_dapm(&codec->component); 1352 struct hdac_hdmi_priv *hdmi = edev->private_data; 1353 struct hdac_hdmi_pcm *pcm; 1354 1355 /* 1356 * this is a new PCM device, create new pcm and 1357 * add to the pcm list 1358 */ 1359 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL); 1360 if (!pcm) 1361 return -ENOMEM; 1362 pcm->pcm_id = device; 1363 pcm->cvt = hdmi->dai_map[dai->id].cvt; 1364 1365 list_add_tail(&pcm->head, &hdmi->pcm_list); 1366 1367 sprintf(jack_name, "HDMI/DP, pcm=%d Jack", device); 1368 1369 return snd_jack_new(dapm->card->snd_card, jack_name, 1370 SND_JACK_AVOUT, &pcm->jack, true, false); 1371 } 1372 EXPORT_SYMBOL_GPL(hdac_hdmi_jack_init); 1373 1374 static int hdmi_codec_probe(struct snd_soc_codec *codec) 1375 { 1376 struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec); 1377 struct hdac_hdmi_priv *hdmi = edev->private_data; 1378 struct snd_soc_dapm_context *dapm = 1379 snd_soc_component_get_dapm(&codec->component); 1380 struct hdac_hdmi_pin *pin; 1381 int ret; 1382 1383 edev->scodec = codec; 1384 1385 ret = create_fill_widget_route_map(dapm); 1386 if (ret < 0) 1387 return ret; 1388 1389 aops.audio_ptr = edev; 1390 ret = snd_hdac_i915_register_notifier(&aops); 1391 if (ret < 0) { 1392 dev_err(&edev->hdac.dev, "notifier register failed: err: %d\n", 1393 ret); 1394 return ret; 1395 } 1396 1397 list_for_each_entry(pin, &hdmi->pin_list, head) 1398 hdac_hdmi_present_sense(pin, 1); 1399 1400 /* Imp: Store the card pointer in hda_codec */ 1401 edev->card = dapm->card->snd_card; 1402 1403 /* 1404 * hdac_device core already sets the state to active and calls 1405 * get_noresume. So enable runtime and set the device to suspend. 1406 */ 1407 pm_runtime_enable(&edev->hdac.dev); 1408 pm_runtime_put(&edev->hdac.dev); 1409 pm_runtime_suspend(&edev->hdac.dev); 1410 1411 return 0; 1412 } 1413 1414 static int hdmi_codec_remove(struct snd_soc_codec *codec) 1415 { 1416 struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec); 1417 1418 pm_runtime_disable(&edev->hdac.dev); 1419 return 0; 1420 } 1421 1422 #ifdef CONFIG_PM 1423 static int hdmi_codec_resume(struct snd_soc_codec *codec) 1424 { 1425 struct hdac_ext_device *edev = snd_soc_codec_get_drvdata(codec); 1426 struct hdac_hdmi_priv *hdmi = edev->private_data; 1427 struct hdac_hdmi_pin *pin; 1428 struct hdac_device *hdac = &edev->hdac; 1429 struct hdac_bus *bus = hdac->bus; 1430 int err; 1431 unsigned long timeout; 1432 1433 hdac_hdmi_skl_enable_all_pins(&edev->hdac); 1434 hdac_hdmi_skl_enable_dp12(&edev->hdac); 1435 1436 /* Power up afg */ 1437 if (!snd_hdac_check_power_state(hdac, hdac->afg, AC_PWRST_D0)) { 1438 1439 snd_hdac_codec_write(hdac, hdac->afg, 0, 1440 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 1441 1442 /* Wait till power state is set to D0 */ 1443 timeout = jiffies + msecs_to_jiffies(1000); 1444 while (!snd_hdac_check_power_state(hdac, hdac->afg, AC_PWRST_D0) 1445 && time_before(jiffies, timeout)) { 1446 msleep(50); 1447 } 1448 } 1449 1450 /* 1451 * As the ELD notify callback request is not entertained while the 1452 * device is in suspend state. Need to manually check detection of 1453 * all pins here. 1454 */ 1455 list_for_each_entry(pin, &hdmi->pin_list, head) 1456 hdac_hdmi_present_sense(pin, 1); 1457 1458 /* 1459 * Codec power is turned ON during controller resume. 1460 * Turn it OFF here 1461 */ 1462 err = snd_hdac_display_power(bus, false); 1463 if (err < 0) { 1464 dev_err(bus->dev, 1465 "Cannot turn OFF display power on i915, err: %d\n", 1466 err); 1467 return err; 1468 } 1469 1470 return 0; 1471 } 1472 #else 1473 #define hdmi_codec_resume NULL 1474 #endif 1475 1476 static struct snd_soc_codec_driver hdmi_hda_codec = { 1477 .probe = hdmi_codec_probe, 1478 .remove = hdmi_codec_remove, 1479 .resume = hdmi_codec_resume, 1480 .idle_bias_off = true, 1481 }; 1482 1483 static int hdac_hdmi_dev_probe(struct hdac_ext_device *edev) 1484 { 1485 struct hdac_device *codec = &edev->hdac; 1486 struct hdac_hdmi_priv *hdmi_priv; 1487 struct snd_soc_dai_driver *hdmi_dais = NULL; 1488 int num_dais = 0; 1489 int ret = 0; 1490 1491 hdmi_priv = devm_kzalloc(&codec->dev, sizeof(*hdmi_priv), GFP_KERNEL); 1492 if (hdmi_priv == NULL) 1493 return -ENOMEM; 1494 1495 edev->private_data = hdmi_priv; 1496 1497 dev_set_drvdata(&codec->dev, edev); 1498 1499 INIT_LIST_HEAD(&hdmi_priv->pin_list); 1500 INIT_LIST_HEAD(&hdmi_priv->cvt_list); 1501 INIT_LIST_HEAD(&hdmi_priv->pcm_list); 1502 mutex_init(&hdmi_priv->pin_mutex); 1503 1504 /* 1505 * Turned off in the runtime_suspend during the first explicit 1506 * pm_runtime_suspend call. 1507 */ 1508 ret = snd_hdac_display_power(edev->hdac.bus, true); 1509 if (ret < 0) { 1510 dev_err(&edev->hdac.dev, 1511 "Cannot turn on display power on i915 err: %d\n", 1512 ret); 1513 return ret; 1514 } 1515 1516 ret = hdac_hdmi_parse_and_map_nid(edev, &hdmi_dais, &num_dais); 1517 if (ret < 0) { 1518 dev_err(&codec->dev, 1519 "Failed in parse and map nid with err: %d\n", ret); 1520 return ret; 1521 } 1522 1523 /* ASoC specific initialization */ 1524 return snd_soc_register_codec(&codec->dev, &hdmi_hda_codec, 1525 hdmi_dais, num_dais); 1526 } 1527 1528 static int hdac_hdmi_dev_remove(struct hdac_ext_device *edev) 1529 { 1530 struct hdac_hdmi_priv *hdmi = edev->private_data; 1531 struct hdac_hdmi_pin *pin, *pin_next; 1532 struct hdac_hdmi_cvt *cvt, *cvt_next; 1533 struct hdac_hdmi_pcm *pcm, *pcm_next; 1534 1535 snd_soc_unregister_codec(&edev->hdac.dev); 1536 1537 list_for_each_entry_safe(pcm, pcm_next, &hdmi->pcm_list, head) { 1538 pcm->cvt = NULL; 1539 pcm->pin = NULL; 1540 list_del(&pcm->head); 1541 kfree(pcm); 1542 } 1543 1544 list_for_each_entry_safe(cvt, cvt_next, &hdmi->cvt_list, head) { 1545 list_del(&cvt->head); 1546 kfree(cvt->name); 1547 kfree(cvt); 1548 } 1549 1550 list_for_each_entry_safe(pin, pin_next, &hdmi->pin_list, head) { 1551 list_del(&pin->head); 1552 kfree(pin); 1553 } 1554 1555 return 0; 1556 } 1557 1558 #ifdef CONFIG_PM 1559 static int hdac_hdmi_runtime_suspend(struct device *dev) 1560 { 1561 struct hdac_ext_device *edev = to_hda_ext_device(dev); 1562 struct hdac_device *hdac = &edev->hdac; 1563 struct hdac_bus *bus = hdac->bus; 1564 unsigned long timeout; 1565 int err; 1566 1567 dev_dbg(dev, "Enter: %s\n", __func__); 1568 1569 /* controller may not have been initialized for the first time */ 1570 if (!bus) 1571 return 0; 1572 1573 /* Power down afg */ 1574 if (!snd_hdac_check_power_state(hdac, hdac->afg, AC_PWRST_D3)) { 1575 snd_hdac_codec_write(hdac, hdac->afg, 0, 1576 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 1577 1578 /* Wait till power state is set to D3 */ 1579 timeout = jiffies + msecs_to_jiffies(1000); 1580 while (!snd_hdac_check_power_state(hdac, hdac->afg, AC_PWRST_D3) 1581 && time_before(jiffies, timeout)) { 1582 1583 msleep(50); 1584 } 1585 } 1586 1587 err = snd_hdac_display_power(bus, false); 1588 if (err < 0) { 1589 dev_err(bus->dev, "Cannot turn on display power on i915\n"); 1590 return err; 1591 } 1592 1593 return 0; 1594 } 1595 1596 static int hdac_hdmi_runtime_resume(struct device *dev) 1597 { 1598 struct hdac_ext_device *edev = to_hda_ext_device(dev); 1599 struct hdac_device *hdac = &edev->hdac; 1600 struct hdac_bus *bus = hdac->bus; 1601 int err; 1602 1603 dev_dbg(dev, "Enter: %s\n", __func__); 1604 1605 /* controller may not have been initialized for the first time */ 1606 if (!bus) 1607 return 0; 1608 1609 err = snd_hdac_display_power(bus, true); 1610 if (err < 0) { 1611 dev_err(bus->dev, "Cannot turn on display power on i915\n"); 1612 return err; 1613 } 1614 1615 hdac_hdmi_skl_enable_all_pins(&edev->hdac); 1616 hdac_hdmi_skl_enable_dp12(&edev->hdac); 1617 1618 /* Power up afg */ 1619 if (!snd_hdac_check_power_state(hdac, hdac->afg, AC_PWRST_D0)) 1620 snd_hdac_codec_write(hdac, hdac->afg, 0, 1621 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 1622 1623 return 0; 1624 } 1625 #else 1626 #define hdac_hdmi_runtime_suspend NULL 1627 #define hdac_hdmi_runtime_resume NULL 1628 #endif 1629 1630 static const struct dev_pm_ops hdac_hdmi_pm = { 1631 SET_RUNTIME_PM_OPS(hdac_hdmi_runtime_suspend, hdac_hdmi_runtime_resume, NULL) 1632 }; 1633 1634 static const struct hda_device_id hdmi_list[] = { 1635 HDA_CODEC_EXT_ENTRY(0x80862809, 0x100000, "Skylake HDMI", 0), 1636 HDA_CODEC_EXT_ENTRY(0x8086280a, 0x100000, "Broxton HDMI", 0), 1637 {} 1638 }; 1639 1640 MODULE_DEVICE_TABLE(hdaudio, hdmi_list); 1641 1642 static struct hdac_ext_driver hdmi_driver = { 1643 . hdac = { 1644 .driver = { 1645 .name = "HDMI HDA Codec", 1646 .pm = &hdac_hdmi_pm, 1647 }, 1648 .id_table = hdmi_list, 1649 }, 1650 .probe = hdac_hdmi_dev_probe, 1651 .remove = hdac_hdmi_dev_remove, 1652 }; 1653 1654 static int __init hdmi_init(void) 1655 { 1656 return snd_hda_ext_driver_register(&hdmi_driver); 1657 } 1658 1659 static void __exit hdmi_exit(void) 1660 { 1661 snd_hda_ext_driver_unregister(&hdmi_driver); 1662 } 1663 1664 module_init(hdmi_init); 1665 module_exit(hdmi_exit); 1666 1667 MODULE_LICENSE("GPL v2"); 1668 MODULE_DESCRIPTION("HDMI HD codec"); 1669 MODULE_AUTHOR("Samreen Nilofer<samreen.nilofer@intel.com>"); 1670 MODULE_AUTHOR("Subhransu S. Prusty<subhransu.s.prusty@intel.com>"); 1671