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