1 /* 2 * Copyright 2012-15 Advanced Micro Devices, Inc. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included in 12 * all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 * 22 * Authors: AMD 23 * 24 */ 25 26 #include <linux/slab.h> 27 28 #include "reg_helper.h" 29 #include "dce_audio.h" 30 #include "dce/dce_11_0_d.h" 31 #include "dce/dce_11_0_sh_mask.h" 32 33 #define DCE_AUD(audio)\ 34 container_of(audio, struct dce_audio, base) 35 36 #define CTX \ 37 aud->base.ctx 38 39 #define DC_LOGGER_INIT() 40 41 #define REG(reg)\ 42 (aud->regs->reg) 43 44 #undef FN 45 #define FN(reg_name, field_name) \ 46 aud->shifts->field_name, aud->masks->field_name 47 48 #define IX_REG(reg)\ 49 ix ## reg 50 51 #define AZ_REG_READ(reg_name) \ 52 read_indirect_azalia_reg(audio, IX_REG(reg_name)) 53 54 #define AZ_REG_WRITE(reg_name, value) \ 55 write_indirect_azalia_reg(audio, IX_REG(reg_name), value) 56 57 static void write_indirect_azalia_reg(struct audio *audio, 58 uint32_t reg_index, 59 uint32_t reg_data) 60 { 61 struct dce_audio *aud = DCE_AUD(audio); 62 63 /* AZALIA_F0_CODEC_ENDPOINT_INDEX endpoint index */ 64 REG_SET(AZALIA_F0_CODEC_ENDPOINT_INDEX, 0, 65 AZALIA_ENDPOINT_REG_INDEX, reg_index); 66 67 /* AZALIA_F0_CODEC_ENDPOINT_DATA endpoint data */ 68 REG_SET(AZALIA_F0_CODEC_ENDPOINT_DATA, 0, 69 AZALIA_ENDPOINT_REG_DATA, reg_data); 70 71 DC_LOG_HW_AUDIO("AUDIO:write_indirect_azalia_reg: index: %u data: %u\n", 72 reg_index, reg_data); 73 } 74 75 static uint32_t read_indirect_azalia_reg(struct audio *audio, uint32_t reg_index) 76 { 77 struct dce_audio *aud = DCE_AUD(audio); 78 79 uint32_t value = 0; 80 81 /* AZALIA_F0_CODEC_ENDPOINT_INDEX endpoint index */ 82 REG_SET(AZALIA_F0_CODEC_ENDPOINT_INDEX, 0, 83 AZALIA_ENDPOINT_REG_INDEX, reg_index); 84 85 /* AZALIA_F0_CODEC_ENDPOINT_DATA endpoint data */ 86 value = REG_READ(AZALIA_F0_CODEC_ENDPOINT_DATA); 87 88 DC_LOG_HW_AUDIO("AUDIO:read_indirect_azalia_reg: index: %u data: %u\n", 89 reg_index, value); 90 91 return value; 92 } 93 94 static bool is_audio_format_supported( 95 const struct audio_info *audio_info, 96 enum audio_format_code audio_format_code, 97 uint32_t *format_index) 98 { 99 uint32_t index; 100 uint32_t max_channe_index = 0; 101 bool found = false; 102 103 if (audio_info == NULL) 104 return found; 105 106 /* pass through whole array */ 107 for (index = 0; index < audio_info->mode_count; index++) { 108 if (audio_info->modes[index].format_code == audio_format_code) { 109 if (found) { 110 /* format has multiply entries, choose one with 111 * highst number of channels */ 112 if (audio_info->modes[index].channel_count > 113 audio_info->modes[max_channe_index].channel_count) { 114 max_channe_index = index; 115 } 116 } else { 117 /* format found, save it's index */ 118 found = true; 119 max_channe_index = index; 120 } 121 } 122 } 123 124 /* return index */ 125 if (found && format_index != NULL) 126 *format_index = max_channe_index; 127 128 return found; 129 } 130 131 /*For HDMI, calculate if specified sample rates can fit into a given timing */ 132 static void check_audio_bandwidth_hdmi( 133 const struct audio_crtc_info *crtc_info, 134 uint32_t channel_count, 135 union audio_sample_rates *sample_rates) 136 { 137 uint32_t samples; 138 uint32_t h_blank; 139 bool limit_freq_to_48_khz = false; 140 bool limit_freq_to_88_2_khz = false; 141 bool limit_freq_to_96_khz = false; 142 bool limit_freq_to_174_4_khz = false; 143 144 /* For two channels supported return whatever sink support,unmodified*/ 145 if (channel_count > 2) { 146 147 /* Based on HDMI spec 1.3 Table 7.5 */ 148 if ((crtc_info->requested_pixel_clock_100Hz <= 270000) && 149 (crtc_info->v_active <= 576) && 150 !(crtc_info->interlaced) && 151 !(crtc_info->pixel_repetition == 2 || 152 crtc_info->pixel_repetition == 4)) { 153 limit_freq_to_48_khz = true; 154 155 } else if ((crtc_info->requested_pixel_clock_100Hz <= 270000) && 156 (crtc_info->v_active <= 576) && 157 (crtc_info->interlaced) && 158 (crtc_info->pixel_repetition == 2)) { 159 limit_freq_to_88_2_khz = true; 160 161 } else if ((crtc_info->requested_pixel_clock_100Hz <= 540000) && 162 (crtc_info->v_active <= 576) && 163 !(crtc_info->interlaced)) { 164 limit_freq_to_174_4_khz = true; 165 } 166 } 167 168 /* Also do some calculation for the available Audio Bandwidth for the 169 * 8 ch (i.e. for the Layout 1 => ch > 2) 170 */ 171 h_blank = crtc_info->h_total - crtc_info->h_active; 172 173 if (crtc_info->pixel_repetition) 174 h_blank *= crtc_info->pixel_repetition; 175 176 /*based on HDMI spec 1.3 Table 7.5 */ 177 h_blank -= 58; 178 /*for Control Period */ 179 h_blank -= 16; 180 181 samples = h_blank * 10; 182 /* Number of Audio Packets (multiplied by 10) per Line (for 8 ch number 183 * of Audio samples per line multiplied by 10 - Layout 1) 184 */ 185 samples /= 32; 186 samples *= crtc_info->v_active; 187 /*Number of samples multiplied by 10, per second */ 188 samples *= crtc_info->refresh_rate; 189 /*Number of Audio samples per second */ 190 samples /= 10; 191 192 /* @todo do it after deep color is implemented 193 * 8xx - deep color bandwidth scaling 194 * Extra bandwidth is avaliable in deep color b/c link runs faster than 195 * pixel rate. This has the effect of allowing more tmds characters to 196 * be transmitted during blank 197 */ 198 199 switch (crtc_info->color_depth) { 200 case COLOR_DEPTH_888: 201 samples *= 4; 202 break; 203 case COLOR_DEPTH_101010: 204 samples *= 5; 205 break; 206 case COLOR_DEPTH_121212: 207 samples *= 6; 208 break; 209 default: 210 samples *= 4; 211 break; 212 } 213 214 samples /= 4; 215 216 /*check limitation*/ 217 if (samples < 88200) 218 limit_freq_to_48_khz = true; 219 else if (samples < 96000) 220 limit_freq_to_88_2_khz = true; 221 else if (samples < 176400) 222 limit_freq_to_96_khz = true; 223 else if (samples < 192000) 224 limit_freq_to_174_4_khz = true; 225 226 if (sample_rates != NULL) { 227 /* limit frequencies */ 228 if (limit_freq_to_174_4_khz) 229 sample_rates->rate.RATE_192 = 0; 230 231 if (limit_freq_to_96_khz) { 232 sample_rates->rate.RATE_192 = 0; 233 sample_rates->rate.RATE_176_4 = 0; 234 } 235 if (limit_freq_to_88_2_khz) { 236 sample_rates->rate.RATE_192 = 0; 237 sample_rates->rate.RATE_176_4 = 0; 238 sample_rates->rate.RATE_96 = 0; 239 } 240 if (limit_freq_to_48_khz) { 241 sample_rates->rate.RATE_192 = 0; 242 sample_rates->rate.RATE_176_4 = 0; 243 sample_rates->rate.RATE_96 = 0; 244 sample_rates->rate.RATE_88_2 = 0; 245 } 246 } 247 } 248 249 /*For DP SST, calculate if specified sample rates can fit into a given timing */ 250 static void check_audio_bandwidth_dpsst( 251 const struct audio_crtc_info *crtc_info, 252 uint32_t channel_count, 253 union audio_sample_rates *sample_rates) 254 { 255 /* do nothing */ 256 } 257 258 /*For DP MST, calculate if specified sample rates can fit into a given timing */ 259 static void check_audio_bandwidth_dpmst( 260 const struct audio_crtc_info *crtc_info, 261 uint32_t channel_count, 262 union audio_sample_rates *sample_rates) 263 { 264 /* do nothing */ 265 } 266 267 static void check_audio_bandwidth( 268 const struct audio_crtc_info *crtc_info, 269 uint32_t channel_count, 270 enum signal_type signal, 271 union audio_sample_rates *sample_rates) 272 { 273 switch (signal) { 274 case SIGNAL_TYPE_HDMI_TYPE_A: 275 check_audio_bandwidth_hdmi( 276 crtc_info, channel_count, sample_rates); 277 break; 278 case SIGNAL_TYPE_EDP: 279 case SIGNAL_TYPE_DISPLAY_PORT: 280 check_audio_bandwidth_dpsst( 281 crtc_info, channel_count, sample_rates); 282 break; 283 case SIGNAL_TYPE_DISPLAY_PORT_MST: 284 check_audio_bandwidth_dpmst( 285 crtc_info, channel_count, sample_rates); 286 break; 287 default: 288 break; 289 } 290 } 291 292 /* expose/not expose HBR capability to Audio driver */ 293 static void set_high_bit_rate_capable( 294 struct audio *audio, 295 bool capable) 296 { 297 uint32_t value = 0; 298 299 /* set high bit rate audio capable*/ 300 value = AZ_REG_READ(AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_HBR); 301 302 set_reg_field_value(value, capable, 303 AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_HBR, 304 HBR_CAPABLE); 305 306 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_HBR, value); 307 } 308 309 /* set video latency in in ms/2+1 */ 310 static void set_video_latency( 311 struct audio *audio, 312 int latency_in_ms) 313 { 314 uint32_t value = 0; 315 316 if ((latency_in_ms < 0) || (latency_in_ms > 255)) 317 return; 318 319 value = AZ_REG_READ(AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_LIPSYNC); 320 321 set_reg_field_value(value, latency_in_ms, 322 AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_LIPSYNC, 323 VIDEO_LIPSYNC); 324 325 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_LIPSYNC, 326 value); 327 } 328 329 /* set audio latency in in ms/2+1 */ 330 static void set_audio_latency( 331 struct audio *audio, 332 int latency_in_ms) 333 { 334 uint32_t value = 0; 335 336 if (latency_in_ms < 0) 337 latency_in_ms = 0; 338 339 if (latency_in_ms > 255) 340 latency_in_ms = 255; 341 342 value = AZ_REG_READ(AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_LIPSYNC); 343 344 set_reg_field_value(value, latency_in_ms, 345 AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_LIPSYNC, 346 AUDIO_LIPSYNC); 347 348 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_LIPSYNC, 349 value); 350 } 351 352 void dce_aud_az_enable(struct audio *audio) 353 { 354 uint32_t value = AZ_REG_READ(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL); 355 DC_LOGGER_INIT(); 356 357 set_reg_field_value(value, 1, 358 AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, 359 CLOCK_GATING_DISABLE); 360 set_reg_field_value(value, 1, 361 AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, 362 AUDIO_ENABLED); 363 364 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, value); 365 set_reg_field_value(value, 0, 366 AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, 367 CLOCK_GATING_DISABLE); 368 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, value); 369 370 DC_LOG_HW_AUDIO("\n\t========= AUDIO:dce_aud_az_enable: index: %u data: 0x%x\n", 371 audio->inst, value); 372 } 373 374 void dce_aud_az_disable(struct audio *audio) 375 { 376 uint32_t value; 377 DC_LOGGER_INIT(); 378 379 value = AZ_REG_READ(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL); 380 set_reg_field_value(value, 1, 381 AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, 382 CLOCK_GATING_DISABLE); 383 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, value); 384 385 set_reg_field_value(value, 0, 386 AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, 387 AUDIO_ENABLED); 388 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, value); 389 390 set_reg_field_value(value, 0, 391 AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, 392 CLOCK_GATING_DISABLE); 393 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, value); 394 value = AZ_REG_READ(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL); 395 DC_LOG_HW_AUDIO("\n\t========= AUDIO:dce_aud_az_disable: index: %u data: 0x%x\n", 396 audio->inst, value); 397 } 398 399 void dce_aud_az_configure( 400 struct audio *audio, 401 enum signal_type signal, 402 const struct audio_crtc_info *crtc_info, 403 const struct audio_info *audio_info) 404 { 405 struct dce_audio *aud = DCE_AUD(audio); 406 407 uint32_t speakers = audio_info->flags.info.ALLSPEAKERS; 408 uint32_t value; 409 uint32_t field = 0; 410 enum audio_format_code audio_format_code; 411 uint32_t format_index; 412 uint32_t index; 413 bool is_ac3_supported = false; 414 union audio_sample_rates sample_rate; 415 uint32_t strlen = 0; 416 value = AZ_REG_READ(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL); 417 set_reg_field_value(value, 1, 418 AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, 419 CLOCK_GATING_DISABLE); 420 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, value); 421 422 /* Speaker Allocation */ 423 /* 424 uint32_t value; 425 uint32_t field = 0;*/ 426 value = AZ_REG_READ(AZALIA_F0_CODEC_PIN_CONTROL_CHANNEL_SPEAKER); 427 428 set_reg_field_value(value, 429 speakers, 430 AZALIA_F0_CODEC_PIN_CONTROL_CHANNEL_SPEAKER, 431 SPEAKER_ALLOCATION); 432 433 /* LFE_PLAYBACK_LEVEL = LFEPBL 434 * LFEPBL = 0 : Unknown or refer to other information 435 * LFEPBL = 1 : 0dB playback 436 * LFEPBL = 2 : +10dB playback 437 * LFE_BL = 3 : Reserved 438 */ 439 set_reg_field_value(value, 440 0, 441 AZALIA_F0_CODEC_PIN_CONTROL_CHANNEL_SPEAKER, 442 LFE_PLAYBACK_LEVEL); 443 /* todo: according to reg spec LFE_PLAYBACK_LEVEL is read only. 444 * why are we writing to it? DCE8 does not write this */ 445 446 447 set_reg_field_value(value, 448 0, 449 AZALIA_F0_CODEC_PIN_CONTROL_CHANNEL_SPEAKER, 450 HDMI_CONNECTION); 451 452 set_reg_field_value(value, 453 0, 454 AZALIA_F0_CODEC_PIN_CONTROL_CHANNEL_SPEAKER, 455 DP_CONNECTION); 456 457 field = get_reg_field_value(value, 458 AZALIA_F0_CODEC_PIN_CONTROL_CHANNEL_SPEAKER, 459 EXTRA_CONNECTION_INFO); 460 461 field &= ~0x1; 462 463 set_reg_field_value(value, 464 field, 465 AZALIA_F0_CODEC_PIN_CONTROL_CHANNEL_SPEAKER, 466 EXTRA_CONNECTION_INFO); 467 468 /* set audio for output signal */ 469 switch (signal) { 470 case SIGNAL_TYPE_HDMI_TYPE_A: 471 set_reg_field_value(value, 472 1, 473 AZALIA_F0_CODEC_PIN_CONTROL_CHANNEL_SPEAKER, 474 HDMI_CONNECTION); 475 476 break; 477 478 case SIGNAL_TYPE_EDP: 479 case SIGNAL_TYPE_DISPLAY_PORT: 480 case SIGNAL_TYPE_DISPLAY_PORT_MST: 481 set_reg_field_value(value, 482 1, 483 AZALIA_F0_CODEC_PIN_CONTROL_CHANNEL_SPEAKER, 484 DP_CONNECTION); 485 break; 486 default: 487 BREAK_TO_DEBUGGER(); 488 break; 489 } 490 491 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_CHANNEL_SPEAKER, value); 492 493 /* Audio Descriptors */ 494 /* pass through all formats */ 495 for (format_index = 0; format_index < AUDIO_FORMAT_CODE_COUNT; 496 format_index++) { 497 audio_format_code = 498 (AUDIO_FORMAT_CODE_FIRST + format_index); 499 500 /* those are unsupported, skip programming */ 501 if (audio_format_code == AUDIO_FORMAT_CODE_1BITAUDIO || 502 audio_format_code == AUDIO_FORMAT_CODE_DST) 503 continue; 504 505 value = 0; 506 507 /* check if supported */ 508 if (is_audio_format_supported( 509 audio_info, audio_format_code, &index)) { 510 const struct audio_mode *audio_mode = 511 &audio_info->modes[index]; 512 union audio_sample_rates sample_rates = 513 audio_mode->sample_rates; 514 uint8_t byte2 = audio_mode->max_bit_rate; 515 516 /* adjust specific properties */ 517 switch (audio_format_code) { 518 case AUDIO_FORMAT_CODE_LINEARPCM: { 519 check_audio_bandwidth( 520 crtc_info, 521 audio_mode->channel_count, 522 signal, 523 &sample_rates); 524 525 byte2 = audio_mode->sample_size; 526 527 set_reg_field_value(value, 528 sample_rates.all, 529 AZALIA_F0_CODEC_PIN_CONTROL_AUDIO_DESCRIPTOR0, 530 SUPPORTED_FREQUENCIES_STEREO); 531 } 532 break; 533 case AUDIO_FORMAT_CODE_AC3: 534 is_ac3_supported = true; 535 break; 536 case AUDIO_FORMAT_CODE_DOLBYDIGITALPLUS: 537 case AUDIO_FORMAT_CODE_DTS_HD: 538 case AUDIO_FORMAT_CODE_MAT_MLP: 539 case AUDIO_FORMAT_CODE_DST: 540 case AUDIO_FORMAT_CODE_WMAPRO: 541 byte2 = audio_mode->vendor_specific; 542 break; 543 default: 544 break; 545 } 546 547 /* fill audio format data */ 548 set_reg_field_value(value, 549 audio_mode->channel_count - 1, 550 AZALIA_F0_CODEC_PIN_CONTROL_AUDIO_DESCRIPTOR0, 551 MAX_CHANNELS); 552 553 set_reg_field_value(value, 554 sample_rates.all, 555 AZALIA_F0_CODEC_PIN_CONTROL_AUDIO_DESCRIPTOR0, 556 SUPPORTED_FREQUENCIES); 557 558 set_reg_field_value(value, 559 byte2, 560 AZALIA_F0_CODEC_PIN_CONTROL_AUDIO_DESCRIPTOR0, 561 DESCRIPTOR_BYTE_2); 562 } /* if */ 563 564 AZ_REG_WRITE( 565 AZALIA_F0_CODEC_PIN_CONTROL_AUDIO_DESCRIPTOR0 + format_index, 566 value); 567 } /* for */ 568 569 if (is_ac3_supported) 570 /* todo: this reg global. why program global register? */ 571 REG_WRITE(AZALIA_F0_CODEC_FUNCTION_PARAMETER_STREAM_FORMATS, 572 0x05); 573 574 /* check for 192khz/8-Ch support for HBR requirements */ 575 sample_rate.all = 0; 576 sample_rate.rate.RATE_192 = 1; 577 578 check_audio_bandwidth( 579 crtc_info, 580 8, 581 signal, 582 &sample_rate); 583 584 set_high_bit_rate_capable(audio, sample_rate.rate.RATE_192); 585 586 /* Audio and Video Lipsync */ 587 set_video_latency(audio, audio_info->video_latency); 588 set_audio_latency(audio, audio_info->audio_latency); 589 590 value = 0; 591 set_reg_field_value(value, audio_info->manufacture_id, 592 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO0, 593 MANUFACTURER_ID); 594 595 set_reg_field_value(value, audio_info->product_id, 596 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO0, 597 PRODUCT_ID); 598 599 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO0, 600 value); 601 602 value = 0; 603 604 /*get display name string length */ 605 while (audio_info->display_name[strlen++] != '\0') { 606 if (strlen >= 607 MAX_HW_AUDIO_INFO_DISPLAY_NAME_SIZE_IN_CHARS) 608 break; 609 } 610 set_reg_field_value(value, strlen, 611 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO1, 612 SINK_DESCRIPTION_LEN); 613 614 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO1, 615 value); 616 DC_LOG_HW_AUDIO("\n\tAUDIO:az_configure: index: %u data, 0x%x, displayName %s: \n", 617 audio->inst, value, audio_info->display_name); 618 619 /* 620 *write the port ID: 621 *PORT_ID0 = display index 622 *PORT_ID1 = 16bit BDF 623 *(format MSB->LSB: 8bit Bus, 5bit Device, 3bit Function) 624 */ 625 626 value = 0; 627 628 set_reg_field_value(value, audio_info->port_id[0], 629 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO2, 630 PORT_ID0); 631 632 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO2, value); 633 634 value = 0; 635 set_reg_field_value(value, audio_info->port_id[1], 636 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO3, 637 PORT_ID1); 638 639 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO3, value); 640 641 /*write the 18 char monitor string */ 642 643 value = 0; 644 set_reg_field_value(value, audio_info->display_name[0], 645 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO4, 646 DESCRIPTION0); 647 648 set_reg_field_value(value, audio_info->display_name[1], 649 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO4, 650 DESCRIPTION1); 651 652 set_reg_field_value(value, audio_info->display_name[2], 653 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO4, 654 DESCRIPTION2); 655 656 set_reg_field_value(value, audio_info->display_name[3], 657 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO4, 658 DESCRIPTION3); 659 660 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO4, value); 661 662 value = 0; 663 set_reg_field_value(value, audio_info->display_name[4], 664 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO5, 665 DESCRIPTION4); 666 667 set_reg_field_value(value, audio_info->display_name[5], 668 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO5, 669 DESCRIPTION5); 670 671 set_reg_field_value(value, audio_info->display_name[6], 672 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO5, 673 DESCRIPTION6); 674 675 set_reg_field_value(value, audio_info->display_name[7], 676 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO5, 677 DESCRIPTION7); 678 679 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO5, value); 680 681 value = 0; 682 set_reg_field_value(value, audio_info->display_name[8], 683 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO6, 684 DESCRIPTION8); 685 686 set_reg_field_value(value, audio_info->display_name[9], 687 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO6, 688 DESCRIPTION9); 689 690 set_reg_field_value(value, audio_info->display_name[10], 691 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO6, 692 DESCRIPTION10); 693 694 set_reg_field_value(value, audio_info->display_name[11], 695 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO6, 696 DESCRIPTION11); 697 698 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO6, value); 699 700 value = 0; 701 set_reg_field_value(value, audio_info->display_name[12], 702 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO7, 703 DESCRIPTION12); 704 705 set_reg_field_value(value, audio_info->display_name[13], 706 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO7, 707 DESCRIPTION13); 708 709 set_reg_field_value(value, audio_info->display_name[14], 710 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO7, 711 DESCRIPTION14); 712 713 set_reg_field_value(value, audio_info->display_name[15], 714 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO7, 715 DESCRIPTION15); 716 717 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO7, value); 718 719 value = 0; 720 set_reg_field_value(value, audio_info->display_name[16], 721 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO8, 722 DESCRIPTION16); 723 724 set_reg_field_value(value, audio_info->display_name[17], 725 AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO8, 726 DESCRIPTION17); 727 728 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_SINK_INFO8, value); 729 value = AZ_REG_READ(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL); 730 set_reg_field_value(value, 0, 731 AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, 732 CLOCK_GATING_DISABLE); 733 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, value); 734 } 735 736 /* 737 * todo: wall clk related functionality probably belong to clock_src. 738 */ 739 740 /* search pixel clock value for Azalia HDMI Audio */ 741 static void get_azalia_clock_info_hdmi( 742 uint32_t crtc_pixel_clock_100hz, 743 uint32_t actual_pixel_clock_100Hz, 744 struct azalia_clock_info *azalia_clock_info) 745 { 746 /* audio_dto_phase= 24 * 10,000; 747 * 24MHz in [100Hz] units */ 748 azalia_clock_info->audio_dto_phase = 749 24 * 10000; 750 751 /* audio_dto_module = PCLKFrequency * 10,000; 752 * [khz] -> [100Hz] */ 753 azalia_clock_info->audio_dto_module = 754 actual_pixel_clock_100Hz; 755 } 756 757 static void get_azalia_clock_info_dp( 758 uint32_t requested_pixel_clock_100Hz, 759 const struct audio_pll_info *pll_info, 760 struct azalia_clock_info *azalia_clock_info) 761 { 762 /* Reported dpDtoSourceClockInkhz value for 763 * DCE8 already adjusted for SS, do not need any 764 * adjustment here anymore 765 */ 766 767 /*audio_dto_phase = 24 * 10,000; 768 * 24MHz in [100Hz] units */ 769 azalia_clock_info->audio_dto_phase = 24 * 10000; 770 771 /*audio_dto_module = dpDtoSourceClockInkhz * 10,000; 772 * [khz] ->[100Hz] */ 773 azalia_clock_info->audio_dto_module = 774 pll_info->dp_dto_source_clock_in_khz * 10; 775 } 776 777 void dce_aud_wall_dto_setup( 778 struct audio *audio, 779 enum signal_type signal, 780 const struct audio_crtc_info *crtc_info, 781 const struct audio_pll_info *pll_info) 782 { 783 struct dce_audio *aud = DCE_AUD(audio); 784 785 struct azalia_clock_info clock_info = { 0 }; 786 787 if (dc_is_hdmi_signal(signal)) { 788 uint32_t src_sel; 789 790 /*DTO0 Programming goal: 791 -generate 24MHz, 128*Fs from 24MHz 792 -use DTO0 when an active HDMI port is connected 793 (optionally a DP is connected) */ 794 795 /* calculate DTO settings */ 796 get_azalia_clock_info_hdmi( 797 crtc_info->requested_pixel_clock_100Hz, 798 crtc_info->calculated_pixel_clock_100Hz, 799 &clock_info); 800 801 DC_LOG_HW_AUDIO("\n%s:Input::requested_pixel_clock_100Hz = %d"\ 802 "calculated_pixel_clock_100Hz =%d\n"\ 803 "audio_dto_module = %d audio_dto_phase =%d \n\n", __func__,\ 804 crtc_info->requested_pixel_clock_100Hz,\ 805 crtc_info->calculated_pixel_clock_100Hz,\ 806 clock_info.audio_dto_module,\ 807 clock_info.audio_dto_phase); 808 809 /* On TN/SI, Program DTO source select and DTO select before 810 programming DTO modulo and DTO phase. These bits must be 811 programmed first, otherwise there will be no HDMI audio at boot 812 up. This is a HW sequence change (different from old ASICs). 813 Caution when changing this programming sequence. 814 815 HDMI enabled, using DTO0 816 program master CRTC for DTO0 */ 817 src_sel = pll_info->dto_source - DTO_SOURCE_ID0; 818 REG_UPDATE_2(DCCG_AUDIO_DTO_SOURCE, 819 DCCG_AUDIO_DTO0_SOURCE_SEL, src_sel, 820 DCCG_AUDIO_DTO_SEL, 0); 821 822 /* module */ 823 REG_UPDATE(DCCG_AUDIO_DTO0_MODULE, 824 DCCG_AUDIO_DTO0_MODULE, clock_info.audio_dto_module); 825 826 /* phase */ 827 REG_UPDATE(DCCG_AUDIO_DTO0_PHASE, 828 DCCG_AUDIO_DTO0_PHASE, clock_info.audio_dto_phase); 829 } else { 830 /*DTO1 Programming goal: 831 -generate 24MHz, 512*Fs, 128*Fs from 24MHz 832 -default is to used DTO1, and switch to DTO0 when an audio 833 master HDMI port is connected 834 -use as default for DP 835 836 calculate DTO settings */ 837 get_azalia_clock_info_dp( 838 crtc_info->requested_pixel_clock_100Hz, 839 pll_info, 840 &clock_info); 841 842 /* Program DTO select before programming DTO modulo and DTO 843 phase. default to use DTO1 */ 844 845 REG_UPDATE(DCCG_AUDIO_DTO_SOURCE, 846 DCCG_AUDIO_DTO_SEL, 1); 847 848 /* DCCG_AUDIO_DTO2_USE_512FBR_DTO, 1) 849 * Select 512fs for DP TODO: web register definition 850 * does not match register header file 851 * DCE11 version it's commented out while DCE8 it's set to 1 852 */ 853 854 /* module */ 855 REG_UPDATE(DCCG_AUDIO_DTO1_MODULE, 856 DCCG_AUDIO_DTO1_MODULE, clock_info.audio_dto_module); 857 858 /* phase */ 859 REG_UPDATE(DCCG_AUDIO_DTO1_PHASE, 860 DCCG_AUDIO_DTO1_PHASE, clock_info.audio_dto_phase); 861 862 REG_UPDATE(DCCG_AUDIO_DTO_SOURCE, 863 DCCG_AUDIO_DTO2_USE_512FBR_DTO, 1); 864 865 } 866 } 867 868 static bool dce_aud_endpoint_valid(struct audio *audio) 869 { 870 uint32_t value; 871 uint32_t port_connectivity; 872 873 value = AZ_REG_READ( 874 AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_CONFIGURATION_DEFAULT); 875 876 port_connectivity = get_reg_field_value(value, 877 AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_CONFIGURATION_DEFAULT, 878 PORT_CONNECTIVITY); 879 880 return !(port_connectivity == 1); 881 } 882 883 /* initialize HW state */ 884 void dce_aud_hw_init( 885 struct audio *audio) 886 { 887 uint32_t value; 888 struct dce_audio *aud = DCE_AUD(audio); 889 890 /* we only need to program the following registers once, so we only do 891 it for the inst 0*/ 892 if (audio->inst != 0) 893 return; 894 895 /* Suport R5 - 32khz 896 * Suport R6 - 44.1khz 897 * Suport R7 - 48khz 898 */ 899 /*disable clock gating before write to endpoint register*/ 900 value = AZ_REG_READ(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL); 901 set_reg_field_value(value, 1, 902 AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, 903 CLOCK_GATING_DISABLE); 904 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, value); 905 REG_UPDATE(AZALIA_F0_CODEC_FUNCTION_PARAMETER_SUPPORTED_SIZE_RATES, 906 AUDIO_RATE_CAPABILITIES, 0x70); 907 908 /*Keep alive bit to verify HW block in BU. */ 909 REG_UPDATE_2(AZALIA_F0_CODEC_FUNCTION_PARAMETER_POWER_STATES, 910 CLKSTOP, 1, 911 EPSS, 1); 912 set_reg_field_value(value, 0, 913 AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, 914 CLOCK_GATING_DISABLE); 915 AZ_REG_WRITE(AZALIA_F0_CODEC_PIN_CONTROL_HOT_PLUG_CONTROL, value); 916 } 917 918 static const struct audio_funcs funcs = { 919 .endpoint_valid = dce_aud_endpoint_valid, 920 .hw_init = dce_aud_hw_init, 921 .wall_dto_setup = dce_aud_wall_dto_setup, 922 .az_enable = dce_aud_az_enable, 923 .az_disable = dce_aud_az_disable, 924 .az_configure = dce_aud_az_configure, 925 .destroy = dce_aud_destroy, 926 }; 927 void dce_aud_destroy(struct audio **audio) 928 { 929 struct dce_audio *aud = DCE_AUD(*audio); 930 931 kfree(aud); 932 *audio = NULL; 933 } 934 935 struct audio *dce_audio_create( 936 struct dc_context *ctx, 937 unsigned int inst, 938 const struct dce_audio_registers *reg, 939 const struct dce_audio_shift *shifts, 940 const struct dce_audio_mask *masks 941 ) 942 { 943 struct dce_audio *audio = kzalloc(sizeof(*audio), GFP_KERNEL); 944 945 if (audio == NULL) { 946 ASSERT_CRITICAL(audio); 947 return NULL; 948 } 949 950 audio->base.ctx = ctx; 951 audio->base.inst = inst; 952 audio->base.funcs = &funcs; 953 954 audio->regs = reg; 955 audio->shifts = shifts; 956 audio->masks = masks; 957 return &audio->base; 958 } 959 960