1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2016-2020, The Linux Foundation. All rights reserved. 4 */ 5 6 7 #define pr_fmt(fmt) "[drm-dp] %s: " fmt, __func__ 8 9 #include <linux/platform_device.h> 10 11 #include <drm/display/drm_dp_helper.h> 12 #include <drm/drm_edid.h> 13 14 #include "dp_catalog.h" 15 #include "dp_audio.h" 16 #include "dp_panel.h" 17 #include "dp_display.h" 18 #include "dp_utils.h" 19 20 struct msm_dp_audio_private { 21 struct platform_device *audio_pdev; 22 struct platform_device *pdev; 23 struct drm_device *drm_dev; 24 struct msm_dp_catalog *catalog; 25 26 u32 channels; 27 28 struct msm_dp_audio msm_dp_audio; 29 }; 30 31 static u32 msm_dp_audio_get_header(struct msm_dp_catalog *catalog, 32 enum msm_dp_catalog_audio_sdp_type sdp, 33 enum msm_dp_catalog_audio_header_type header) 34 { 35 return msm_dp_catalog_audio_get_header(catalog, sdp, header); 36 } 37 38 static void msm_dp_audio_set_header(struct msm_dp_catalog *catalog, 39 u32 data, 40 enum msm_dp_catalog_audio_sdp_type sdp, 41 enum msm_dp_catalog_audio_header_type header) 42 { 43 msm_dp_catalog_audio_set_header(catalog, sdp, header, data); 44 } 45 46 static void msm_dp_audio_stream_sdp(struct msm_dp_audio_private *audio) 47 { 48 struct msm_dp_catalog *catalog = audio->catalog; 49 u32 value, new_value; 50 u8 parity_byte; 51 52 /* Config header and parity byte 1 */ 53 value = msm_dp_audio_get_header(catalog, 54 DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_1); 55 56 new_value = 0x02; 57 parity_byte = msm_dp_utils_calculate_parity(new_value); 58 value |= ((new_value << HEADER_BYTE_1_BIT) 59 | (parity_byte << PARITY_BYTE_1_BIT)); 60 drm_dbg_dp(audio->drm_dev, 61 "Header Byte 1: value = 0x%x, parity_byte = 0x%x\n", 62 value, parity_byte); 63 msm_dp_audio_set_header(catalog, value, 64 DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_1); 65 66 /* Config header and parity byte 2 */ 67 value = msm_dp_audio_get_header(catalog, 68 DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_2); 69 new_value = value; 70 parity_byte = msm_dp_utils_calculate_parity(new_value); 71 value |= ((new_value << HEADER_BYTE_2_BIT) 72 | (parity_byte << PARITY_BYTE_2_BIT)); 73 drm_dbg_dp(audio->drm_dev, 74 "Header Byte 2: value = 0x%x, parity_byte = 0x%x\n", 75 value, parity_byte); 76 77 msm_dp_audio_set_header(catalog, value, 78 DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_2); 79 80 /* Config header and parity byte 3 */ 81 value = msm_dp_audio_get_header(catalog, 82 DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_3); 83 84 new_value = audio->channels - 1; 85 parity_byte = msm_dp_utils_calculate_parity(new_value); 86 value |= ((new_value << HEADER_BYTE_3_BIT) 87 | (parity_byte << PARITY_BYTE_3_BIT)); 88 drm_dbg_dp(audio->drm_dev, 89 "Header Byte 3: value = 0x%x, parity_byte = 0x%x\n", 90 value, parity_byte); 91 92 msm_dp_audio_set_header(catalog, value, 93 DP_AUDIO_SDP_STREAM, DP_AUDIO_SDP_HEADER_3); 94 } 95 96 static void msm_dp_audio_timestamp_sdp(struct msm_dp_audio_private *audio) 97 { 98 struct msm_dp_catalog *catalog = audio->catalog; 99 u32 value, new_value; 100 u8 parity_byte; 101 102 /* Config header and parity byte 1 */ 103 value = msm_dp_audio_get_header(catalog, 104 DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_1); 105 106 new_value = 0x1; 107 parity_byte = msm_dp_utils_calculate_parity(new_value); 108 value |= ((new_value << HEADER_BYTE_1_BIT) 109 | (parity_byte << PARITY_BYTE_1_BIT)); 110 drm_dbg_dp(audio->drm_dev, 111 "Header Byte 1: value = 0x%x, parity_byte = 0x%x\n", 112 value, parity_byte); 113 msm_dp_audio_set_header(catalog, value, 114 DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_1); 115 116 /* Config header and parity byte 2 */ 117 value = msm_dp_audio_get_header(catalog, 118 DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_2); 119 120 new_value = 0x17; 121 parity_byte = msm_dp_utils_calculate_parity(new_value); 122 value |= ((new_value << HEADER_BYTE_2_BIT) 123 | (parity_byte << PARITY_BYTE_2_BIT)); 124 drm_dbg_dp(audio->drm_dev, 125 "Header Byte 2: value = 0x%x, parity_byte = 0x%x\n", 126 value, parity_byte); 127 msm_dp_audio_set_header(catalog, value, 128 DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_2); 129 130 /* Config header and parity byte 3 */ 131 value = msm_dp_audio_get_header(catalog, 132 DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_3); 133 134 new_value = (0x0 | (0x11 << 2)); 135 parity_byte = msm_dp_utils_calculate_parity(new_value); 136 value |= ((new_value << HEADER_BYTE_3_BIT) 137 | (parity_byte << PARITY_BYTE_3_BIT)); 138 drm_dbg_dp(audio->drm_dev, 139 "Header Byte 3: value = 0x%x, parity_byte = 0x%x\n", 140 value, parity_byte); 141 msm_dp_audio_set_header(catalog, value, 142 DP_AUDIO_SDP_TIMESTAMP, DP_AUDIO_SDP_HEADER_3); 143 } 144 145 static void msm_dp_audio_infoframe_sdp(struct msm_dp_audio_private *audio) 146 { 147 struct msm_dp_catalog *catalog = audio->catalog; 148 u32 value, new_value; 149 u8 parity_byte; 150 151 /* Config header and parity byte 1 */ 152 value = msm_dp_audio_get_header(catalog, 153 DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_1); 154 155 new_value = 0x84; 156 parity_byte = msm_dp_utils_calculate_parity(new_value); 157 value |= ((new_value << HEADER_BYTE_1_BIT) 158 | (parity_byte << PARITY_BYTE_1_BIT)); 159 drm_dbg_dp(audio->drm_dev, 160 "Header Byte 1: value = 0x%x, parity_byte = 0x%x\n", 161 value, parity_byte); 162 msm_dp_audio_set_header(catalog, value, 163 DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_1); 164 165 /* Config header and parity byte 2 */ 166 value = msm_dp_audio_get_header(catalog, 167 DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_2); 168 169 new_value = 0x1b; 170 parity_byte = msm_dp_utils_calculate_parity(new_value); 171 value |= ((new_value << HEADER_BYTE_2_BIT) 172 | (parity_byte << PARITY_BYTE_2_BIT)); 173 drm_dbg_dp(audio->drm_dev, 174 "Header Byte 2: value = 0x%x, parity_byte = 0x%x\n", 175 value, parity_byte); 176 msm_dp_audio_set_header(catalog, value, 177 DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_2); 178 179 /* Config header and parity byte 3 */ 180 value = msm_dp_audio_get_header(catalog, 181 DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_3); 182 183 new_value = (0x0 | (0x11 << 2)); 184 parity_byte = msm_dp_utils_calculate_parity(new_value); 185 value |= ((new_value << HEADER_BYTE_3_BIT) 186 | (parity_byte << PARITY_BYTE_3_BIT)); 187 drm_dbg_dp(audio->drm_dev, 188 "Header Byte 3: value = 0x%x, parity_byte = 0x%x\n", 189 new_value, parity_byte); 190 msm_dp_audio_set_header(catalog, value, 191 DP_AUDIO_SDP_INFOFRAME, DP_AUDIO_SDP_HEADER_3); 192 } 193 194 static void msm_dp_audio_copy_management_sdp(struct msm_dp_audio_private *audio) 195 { 196 struct msm_dp_catalog *catalog = audio->catalog; 197 u32 value, new_value; 198 u8 parity_byte; 199 200 /* Config header and parity byte 1 */ 201 value = msm_dp_audio_get_header(catalog, 202 DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_1); 203 204 new_value = 0x05; 205 parity_byte = msm_dp_utils_calculate_parity(new_value); 206 value |= ((new_value << HEADER_BYTE_1_BIT) 207 | (parity_byte << PARITY_BYTE_1_BIT)); 208 drm_dbg_dp(audio->drm_dev, 209 "Header Byte 1: value = 0x%x, parity_byte = 0x%x\n", 210 value, parity_byte); 211 msm_dp_audio_set_header(catalog, value, 212 DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_1); 213 214 /* Config header and parity byte 2 */ 215 value = msm_dp_audio_get_header(catalog, 216 DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_2); 217 218 new_value = 0x0F; 219 parity_byte = msm_dp_utils_calculate_parity(new_value); 220 value |= ((new_value << HEADER_BYTE_2_BIT) 221 | (parity_byte << PARITY_BYTE_2_BIT)); 222 drm_dbg_dp(audio->drm_dev, 223 "Header Byte 2: value = 0x%x, parity_byte = 0x%x\n", 224 value, parity_byte); 225 msm_dp_audio_set_header(catalog, value, 226 DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_2); 227 228 /* Config header and parity byte 3 */ 229 value = msm_dp_audio_get_header(catalog, 230 DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_3); 231 232 new_value = 0x0; 233 parity_byte = msm_dp_utils_calculate_parity(new_value); 234 value |= ((new_value << HEADER_BYTE_3_BIT) 235 | (parity_byte << PARITY_BYTE_3_BIT)); 236 drm_dbg_dp(audio->drm_dev, 237 "Header Byte 3: value = 0x%x, parity_byte = 0x%x\n", 238 value, parity_byte); 239 msm_dp_audio_set_header(catalog, value, 240 DP_AUDIO_SDP_COPYMANAGEMENT, DP_AUDIO_SDP_HEADER_3); 241 } 242 243 static void msm_dp_audio_isrc_sdp(struct msm_dp_audio_private *audio) 244 { 245 struct msm_dp_catalog *catalog = audio->catalog; 246 u32 value, new_value; 247 u8 parity_byte; 248 249 /* Config header and parity byte 1 */ 250 value = msm_dp_audio_get_header(catalog, 251 DP_AUDIO_SDP_ISRC, DP_AUDIO_SDP_HEADER_1); 252 253 new_value = 0x06; 254 parity_byte = msm_dp_utils_calculate_parity(new_value); 255 value |= ((new_value << HEADER_BYTE_1_BIT) 256 | (parity_byte << PARITY_BYTE_1_BIT)); 257 drm_dbg_dp(audio->drm_dev, 258 "Header Byte 1: value = 0x%x, parity_byte = 0x%x\n", 259 value, parity_byte); 260 msm_dp_audio_set_header(catalog, value, 261 DP_AUDIO_SDP_ISRC, DP_AUDIO_SDP_HEADER_1); 262 263 /* Config header and parity byte 2 */ 264 value = msm_dp_audio_get_header(catalog, 265 DP_AUDIO_SDP_ISRC, DP_AUDIO_SDP_HEADER_2); 266 267 new_value = 0x0F; 268 parity_byte = msm_dp_utils_calculate_parity(new_value); 269 value |= ((new_value << HEADER_BYTE_2_BIT) 270 | (parity_byte << PARITY_BYTE_2_BIT)); 271 drm_dbg_dp(audio->drm_dev, 272 "Header Byte 2: value = 0x%x, parity_byte = 0x%x\n", 273 value, parity_byte); 274 msm_dp_audio_set_header(catalog, value, 275 DP_AUDIO_SDP_ISRC, DP_AUDIO_SDP_HEADER_2); 276 } 277 278 static void msm_dp_audio_setup_sdp(struct msm_dp_audio_private *audio) 279 { 280 msm_dp_catalog_audio_config_sdp(audio->catalog); 281 282 msm_dp_audio_stream_sdp(audio); 283 msm_dp_audio_timestamp_sdp(audio); 284 msm_dp_audio_infoframe_sdp(audio); 285 msm_dp_audio_copy_management_sdp(audio); 286 msm_dp_audio_isrc_sdp(audio); 287 } 288 289 static void msm_dp_audio_setup_acr(struct msm_dp_audio_private *audio) 290 { 291 u32 select = 0; 292 struct msm_dp_catalog *catalog = audio->catalog; 293 294 switch (audio->msm_dp_audio.bw_code) { 295 case DP_LINK_BW_1_62: 296 select = 0; 297 break; 298 case DP_LINK_BW_2_7: 299 select = 1; 300 break; 301 case DP_LINK_BW_5_4: 302 select = 2; 303 break; 304 case DP_LINK_BW_8_1: 305 select = 3; 306 break; 307 default: 308 drm_dbg_dp(audio->drm_dev, "Unknown link rate\n"); 309 select = 0; 310 break; 311 } 312 313 msm_dp_catalog_audio_config_acr(catalog, select); 314 } 315 316 static void msm_dp_audio_safe_to_exit_level(struct msm_dp_audio_private *audio) 317 { 318 struct msm_dp_catalog *catalog = audio->catalog; 319 u32 safe_to_exit_level = 0; 320 321 switch (audio->msm_dp_audio.lane_count) { 322 case 1: 323 safe_to_exit_level = 14; 324 break; 325 case 2: 326 safe_to_exit_level = 8; 327 break; 328 case 4: 329 safe_to_exit_level = 5; 330 break; 331 default: 332 drm_dbg_dp(audio->drm_dev, 333 "setting the default safe_to_exit_level = %u\n", 334 safe_to_exit_level); 335 safe_to_exit_level = 14; 336 break; 337 } 338 339 msm_dp_catalog_audio_sfe_level(catalog, safe_to_exit_level); 340 } 341 342 static void msm_dp_audio_enable(struct msm_dp_audio_private *audio, bool enable) 343 { 344 struct msm_dp_catalog *catalog = audio->catalog; 345 346 msm_dp_catalog_audio_enable(catalog, enable); 347 } 348 349 static struct msm_dp_audio_private *msm_dp_audio_get_data(struct platform_device *pdev) 350 { 351 struct msm_dp_audio *msm_dp_audio; 352 struct msm_dp *msm_dp_display; 353 354 if (!pdev) { 355 DRM_ERROR("invalid input\n"); 356 return ERR_PTR(-ENODEV); 357 } 358 359 msm_dp_display = platform_get_drvdata(pdev); 360 if (!msm_dp_display) { 361 DRM_ERROR("invalid input\n"); 362 return ERR_PTR(-ENODEV); 363 } 364 365 msm_dp_audio = msm_dp_display->msm_dp_audio; 366 367 if (!msm_dp_audio) { 368 DRM_ERROR("invalid msm_dp_audio data\n"); 369 return ERR_PTR(-EINVAL); 370 } 371 372 return container_of(msm_dp_audio, struct msm_dp_audio_private, msm_dp_audio); 373 } 374 375 static int msm_dp_audio_hook_plugged_cb(struct device *dev, void *data, 376 hdmi_codec_plugged_cb fn, 377 struct device *codec_dev) 378 { 379 380 struct platform_device *pdev; 381 struct msm_dp *msm_dp_display; 382 383 pdev = to_platform_device(dev); 384 if (!pdev) { 385 pr_err("invalid input\n"); 386 return -ENODEV; 387 } 388 389 msm_dp_display = platform_get_drvdata(pdev); 390 if (!msm_dp_display) { 391 pr_err("invalid input\n"); 392 return -ENODEV; 393 } 394 395 return msm_dp_display_set_plugged_cb(msm_dp_display, fn, codec_dev); 396 } 397 398 static int msm_dp_audio_get_eld(struct device *dev, 399 void *data, uint8_t *buf, size_t len) 400 { 401 struct platform_device *pdev; 402 struct msm_dp *msm_dp_display; 403 404 pdev = to_platform_device(dev); 405 406 if (!pdev) { 407 DRM_ERROR("invalid input\n"); 408 return -ENODEV; 409 } 410 411 msm_dp_display = platform_get_drvdata(pdev); 412 if (!msm_dp_display) { 413 DRM_ERROR("invalid input\n"); 414 return -ENODEV; 415 } 416 417 mutex_lock(&msm_dp_display->connector->eld_mutex); 418 memcpy(buf, msm_dp_display->connector->eld, 419 min(sizeof(msm_dp_display->connector->eld), len)); 420 mutex_unlock(&msm_dp_display->connector->eld_mutex); 421 422 return 0; 423 } 424 425 int msm_dp_audio_hw_params(struct device *dev, 426 void *data, 427 struct hdmi_codec_daifmt *daifmt, 428 struct hdmi_codec_params *params) 429 { 430 int rc = 0; 431 struct msm_dp_audio_private *audio; 432 struct platform_device *pdev; 433 struct msm_dp *msm_dp_display; 434 435 pdev = to_platform_device(dev); 436 msm_dp_display = platform_get_drvdata(pdev); 437 438 /* 439 * there could be cases where sound card can be opened even 440 * before OR even when DP is not connected . This can cause 441 * unclocked access as the audio subsystem relies on the DP 442 * driver to maintain the correct state of clocks. To protect 443 * such cases check for connection status and bail out if not 444 * connected. 445 */ 446 if (!msm_dp_display->power_on) { 447 rc = -EINVAL; 448 goto end; 449 } 450 451 audio = msm_dp_audio_get_data(pdev); 452 if (IS_ERR(audio)) { 453 rc = PTR_ERR(audio); 454 goto end; 455 } 456 457 audio->channels = params->channels; 458 459 msm_dp_audio_setup_sdp(audio); 460 msm_dp_audio_setup_acr(audio); 461 msm_dp_audio_safe_to_exit_level(audio); 462 msm_dp_audio_enable(audio, true); 463 msm_dp_display_signal_audio_start(msm_dp_display); 464 msm_dp_display->audio_enabled = true; 465 466 end: 467 return rc; 468 } 469 470 static void msm_dp_audio_shutdown(struct device *dev, void *data) 471 { 472 struct msm_dp_audio_private *audio; 473 struct platform_device *pdev; 474 struct msm_dp *msm_dp_display; 475 476 pdev = to_platform_device(dev); 477 msm_dp_display = platform_get_drvdata(pdev); 478 audio = msm_dp_audio_get_data(pdev); 479 if (IS_ERR(audio)) { 480 DRM_ERROR("failed to get audio data\n"); 481 return; 482 } 483 484 /* 485 * if audio was not enabled there is no need 486 * to execute the shutdown and we can bail out early. 487 * This also makes sure that we dont cause an unclocked 488 * access when audio subsystem calls this without DP being 489 * connected. is_connected cannot be used here as its set 490 * to false earlier than this call 491 */ 492 if (!msm_dp_display->audio_enabled) 493 return; 494 495 msm_dp_audio_enable(audio, false); 496 /* signal the dp display to safely shutdown clocks */ 497 msm_dp_display_signal_audio_complete(msm_dp_display); 498 } 499 500 static const struct hdmi_codec_ops msm_dp_audio_codec_ops = { 501 .hw_params = msm_dp_audio_hw_params, 502 .audio_shutdown = msm_dp_audio_shutdown, 503 .get_eld = msm_dp_audio_get_eld, 504 .hook_plugged_cb = msm_dp_audio_hook_plugged_cb, 505 }; 506 507 static struct hdmi_codec_pdata codec_data = { 508 .ops = &msm_dp_audio_codec_ops, 509 .max_i2s_channels = 8, 510 .i2s = 1, 511 }; 512 513 void msm_dp_unregister_audio_driver(struct device *dev, struct msm_dp_audio *msm_dp_audio) 514 { 515 struct msm_dp_audio_private *audio_priv; 516 517 audio_priv = container_of(msm_dp_audio, struct msm_dp_audio_private, msm_dp_audio); 518 519 if (audio_priv->audio_pdev) { 520 platform_device_unregister(audio_priv->audio_pdev); 521 audio_priv->audio_pdev = NULL; 522 } 523 } 524 525 int msm_dp_register_audio_driver(struct device *dev, 526 struct msm_dp_audio *msm_dp_audio) 527 { 528 struct msm_dp_audio_private *audio_priv; 529 530 audio_priv = container_of(msm_dp_audio, 531 struct msm_dp_audio_private, msm_dp_audio); 532 533 audio_priv->audio_pdev = platform_device_register_data(dev, 534 HDMI_CODEC_DRV_NAME, 535 PLATFORM_DEVID_AUTO, 536 &codec_data, 537 sizeof(codec_data)); 538 return PTR_ERR_OR_ZERO(audio_priv->audio_pdev); 539 } 540 541 struct msm_dp_audio *msm_dp_audio_get(struct platform_device *pdev, 542 struct msm_dp_panel *panel, 543 struct msm_dp_catalog *catalog) 544 { 545 int rc = 0; 546 struct msm_dp_audio_private *audio; 547 struct msm_dp_audio *msm_dp_audio; 548 549 if (!pdev || !panel || !catalog) { 550 DRM_ERROR("invalid input\n"); 551 rc = -EINVAL; 552 goto error; 553 } 554 555 audio = devm_kzalloc(&pdev->dev, sizeof(*audio), GFP_KERNEL); 556 if (!audio) { 557 rc = -ENOMEM; 558 goto error; 559 } 560 561 audio->pdev = pdev; 562 audio->catalog = catalog; 563 564 msm_dp_audio = &audio->msm_dp_audio; 565 566 msm_dp_catalog_audio_init(catalog); 567 568 return msm_dp_audio; 569 error: 570 return ERR_PTR(rc); 571 } 572 573 void msm_dp_audio_put(struct msm_dp_audio *msm_dp_audio) 574 { 575 struct msm_dp_audio_private *audio; 576 577 if (!msm_dp_audio) 578 return; 579 580 audio = container_of(msm_dp_audio, struct msm_dp_audio_private, msm_dp_audio); 581 582 devm_kfree(&audio->pdev->dev, audio); 583 } 584