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