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