Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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_audio.h"
15#include "dp_drm.h"
16#include "dp_panel.h"
17#include "dp_reg.h"
18#include "dp_display.h"
19#include "dp_utils.h"
20
21struct msm_dp_audio_private {
22 struct platform_device *pdev;
23 struct drm_device *drm_dev;
24 void __iomem *link_base;
25
26 u32 channels;
27
28 struct msm_dp_audio msm_dp_audio;
29};
30
31static inline u32 msm_dp_read_link(struct msm_dp_audio_private *audio, u32 offset)
32{
33 return readl_relaxed(audio->link_base + offset);
34}
35
36static inline void msm_dp_write_link(struct msm_dp_audio_private *audio,
37 u32 offset, u32 data)
38{
39 /*
40 * To make sure link reg writes happens before any other operation,
41 * this function uses writel() instread of writel_relaxed()
42 */
43 writel(data, audio->link_base + offset);
44}
45
46static void msm_dp_audio_stream_sdp(struct msm_dp_audio_private *audio)
47{
48 struct dp_sdp_header sdp_hdr = {
49 .HB0 = 0x00,
50 .HB1 = 0x02,
51 .HB2 = 0x00,
52 .HB3 = audio->channels - 1,
53 };
54 u32 header[2];
55
56 msm_dp_utils_pack_sdp_header(&sdp_hdr, header);
57
58 msm_dp_write_link(audio, MMSS_DP_AUDIO_STREAM_0, header[0]);
59 msm_dp_write_link(audio, MMSS_DP_AUDIO_STREAM_1, header[1]);
60}
61
62static void msm_dp_audio_timestamp_sdp(struct msm_dp_audio_private *audio)
63{
64 struct dp_sdp_header sdp_hdr = {
65 .HB0 = 0x00,
66 .HB1 = 0x01,
67 .HB2 = 0x17,
68 .HB3 = 0x0 | (0x11 << 2),
69 };
70 u32 header[2];
71
72 msm_dp_utils_pack_sdp_header(&sdp_hdr, header);
73
74 msm_dp_write_link(audio, MMSS_DP_AUDIO_TIMESTAMP_0, header[0]);
75 msm_dp_write_link(audio, MMSS_DP_AUDIO_TIMESTAMP_1, header[1]);
76}
77
78static void msm_dp_audio_infoframe_sdp(struct msm_dp_audio_private *audio)
79{
80 struct dp_sdp_header sdp_hdr = {
81 .HB0 = 0x00,
82 .HB1 = 0x84,
83 .HB2 = 0x1b,
84 .HB3 = 0x0 | (0x11 << 2),
85 };
86 u32 header[2];
87
88 msm_dp_utils_pack_sdp_header(&sdp_hdr, header);
89
90 msm_dp_write_link(audio, MMSS_DP_AUDIO_INFOFRAME_0, header[0]);
91 msm_dp_write_link(audio, MMSS_DP_AUDIO_INFOFRAME_1, header[1]);
92}
93
94static void msm_dp_audio_copy_management_sdp(struct msm_dp_audio_private *audio)
95{
96 struct dp_sdp_header sdp_hdr = {
97 .HB0 = 0x00,
98 .HB1 = 0x05,
99 .HB2 = 0x0f,
100 .HB3 = 0x00,
101 };
102 u32 header[2];
103
104 msm_dp_utils_pack_sdp_header(&sdp_hdr, header);
105
106 msm_dp_write_link(audio, MMSS_DP_AUDIO_COPYMANAGEMENT_0, header[0]);
107 msm_dp_write_link(audio, MMSS_DP_AUDIO_COPYMANAGEMENT_1, header[1]);
108}
109
110static void msm_dp_audio_isrc_sdp(struct msm_dp_audio_private *audio)
111{
112 struct dp_sdp_header sdp_hdr = {
113 .HB0 = 0x00,
114 .HB1 = 0x06,
115 .HB2 = 0x0f,
116 .HB3 = 0x00,
117 };
118 u32 header[2];
119 u32 reg;
120
121 /* XXX: is it necessary to preserve this field? */
122 reg = msm_dp_read_link(audio, MMSS_DP_AUDIO_ISRC_1);
123 sdp_hdr.HB3 = FIELD_GET(HEADER_3_MASK, reg);
124
125 msm_dp_utils_pack_sdp_header(&sdp_hdr, header);
126
127 msm_dp_write_link(audio, MMSS_DP_AUDIO_ISRC_0, header[0]);
128 msm_dp_write_link(audio, MMSS_DP_AUDIO_ISRC_1, header[1]);
129}
130
131static void msm_dp_audio_config_sdp(struct msm_dp_audio_private *audio)
132{
133 u32 sdp_cfg, sdp_cfg2;
134
135 sdp_cfg = msm_dp_read_link(audio, MMSS_DP_SDP_CFG);
136 /* AUDIO_TIMESTAMP_SDP_EN */
137 sdp_cfg |= BIT(1);
138 /* AUDIO_STREAM_SDP_EN */
139 sdp_cfg |= BIT(2);
140 /* AUDIO_COPY_MANAGEMENT_SDP_EN */
141 sdp_cfg |= BIT(5);
142 /* AUDIO_ISRC_SDP_EN */
143 sdp_cfg |= BIT(6);
144 /* AUDIO_INFOFRAME_SDP_EN */
145 sdp_cfg |= BIT(20);
146
147 drm_dbg_dp(audio->drm_dev, "sdp_cfg = 0x%x\n", sdp_cfg);
148
149 msm_dp_write_link(audio, MMSS_DP_SDP_CFG, sdp_cfg);
150
151 sdp_cfg2 = msm_dp_read_link(audio, MMSS_DP_SDP_CFG2);
152 /* IFRM_REGSRC -> Do not use reg values */
153 sdp_cfg2 &= ~BIT(0);
154 /* AUDIO_STREAM_HB3_REGSRC-> Do not use reg values */
155 sdp_cfg2 &= ~BIT(1);
156
157 drm_dbg_dp(audio->drm_dev, "sdp_cfg2 = 0x%x\n", sdp_cfg2);
158
159 msm_dp_write_link(audio, MMSS_DP_SDP_CFG2, sdp_cfg2);
160}
161
162static void msm_dp_audio_setup_sdp(struct msm_dp_audio_private *audio)
163{
164 msm_dp_audio_config_sdp(audio);
165
166 msm_dp_audio_stream_sdp(audio);
167 msm_dp_audio_timestamp_sdp(audio);
168 msm_dp_audio_infoframe_sdp(audio);
169 msm_dp_audio_copy_management_sdp(audio);
170 msm_dp_audio_isrc_sdp(audio);
171}
172
173static void msm_dp_audio_setup_acr(struct msm_dp_audio_private *audio)
174{
175 u32 select, acr_ctrl;
176
177 switch (audio->msm_dp_audio.bw_code) {
178 case DP_LINK_BW_1_62:
179 select = 0;
180 break;
181 case DP_LINK_BW_2_7:
182 select = 1;
183 break;
184 case DP_LINK_BW_5_4:
185 select = 2;
186 break;
187 case DP_LINK_BW_8_1:
188 select = 3;
189 break;
190 default:
191 drm_dbg_dp(audio->drm_dev, "Unknown link rate\n");
192 select = 0;
193 break;
194 }
195
196 acr_ctrl = select << 4 | BIT(31) | BIT(8) | BIT(14);
197
198 drm_dbg_dp(audio->drm_dev, "select: %#x, acr_ctrl: %#x\n",
199 select, acr_ctrl);
200
201 msm_dp_write_link(audio, MMSS_DP_AUDIO_ACR_CTRL, acr_ctrl);
202}
203
204static void msm_dp_audio_safe_to_exit_level(struct msm_dp_audio_private *audio)
205{
206 u32 safe_to_exit_level, mainlink_levels;
207
208 switch (audio->msm_dp_audio.lane_count) {
209 case 1:
210 safe_to_exit_level = 14;
211 break;
212 case 2:
213 safe_to_exit_level = 8;
214 break;
215 case 4:
216 safe_to_exit_level = 5;
217 break;
218 default:
219 safe_to_exit_level = 14;
220 drm_dbg_dp(audio->drm_dev,
221 "setting the default safe_to_exit_level = %u\n",
222 safe_to_exit_level);
223 break;
224 }
225
226 mainlink_levels = msm_dp_read_link(audio, REG_DP_MAINLINK_LEVELS);
227 mainlink_levels &= 0xFE0;
228 mainlink_levels |= safe_to_exit_level;
229
230 drm_dbg_dp(audio->drm_dev,
231 "mainlink_level = 0x%x, safe_to_exit_level = 0x%x\n",
232 mainlink_levels, safe_to_exit_level);
233
234 msm_dp_write_link(audio, REG_DP_MAINLINK_LEVELS, mainlink_levels);
235}
236
237static void msm_dp_audio_enable(struct msm_dp_audio_private *audio, bool enable)
238{
239 u32 audio_ctrl;
240
241 audio_ctrl = msm_dp_read_link(audio, MMSS_DP_AUDIO_CFG);
242
243 if (enable)
244 audio_ctrl |= BIT(0);
245 else
246 audio_ctrl &= ~BIT(0);
247
248 drm_dbg_dp(audio->drm_dev, "dp_audio_cfg = 0x%x\n", audio_ctrl);
249
250 msm_dp_write_link(audio, MMSS_DP_AUDIO_CFG, audio_ctrl);
251 /* make sure audio engine is disabled */
252 wmb();
253}
254
255static struct msm_dp_audio_private *msm_dp_audio_get_data(struct msm_dp *msm_dp_display)
256{
257 struct msm_dp_audio *msm_dp_audio;
258
259 msm_dp_audio = msm_dp_display->msm_dp_audio;
260 if (!msm_dp_audio) {
261 DRM_ERROR("invalid msm_dp_audio data\n");
262 return ERR_PTR(-EINVAL);
263 }
264
265 return container_of(msm_dp_audio, struct msm_dp_audio_private, msm_dp_audio);
266}
267
268int msm_dp_audio_prepare(struct drm_bridge *bridge,
269 struct drm_connector *connector,
270 struct hdmi_codec_daifmt *daifmt,
271 struct hdmi_codec_params *params)
272{
273 int rc = 0;
274 struct msm_dp_audio_private *audio;
275 struct msm_dp *msm_dp_display;
276
277 msm_dp_display = to_dp_bridge(bridge)->msm_dp_display;
278
279 /*
280 * there could be cases where sound card can be opened even
281 * before OR even when DP is not connected . This can cause
282 * unclocked access as the audio subsystem relies on the DP
283 * driver to maintain the correct state of clocks. To protect
284 * such cases check for connection status and bail out if not
285 * connected.
286 */
287 if (!msm_dp_display->power_on) {
288 rc = -EINVAL;
289 goto end;
290 }
291
292 audio = msm_dp_audio_get_data(msm_dp_display);
293 if (IS_ERR(audio)) {
294 rc = PTR_ERR(audio);
295 goto end;
296 }
297
298 audio->channels = params->channels;
299
300 msm_dp_audio_setup_sdp(audio);
301 msm_dp_audio_setup_acr(audio);
302 msm_dp_audio_safe_to_exit_level(audio);
303 msm_dp_audio_enable(audio, true);
304 msm_dp_display_signal_audio_start(msm_dp_display);
305 msm_dp_display->audio_enabled = true;
306
307end:
308 return rc;
309}
310
311void msm_dp_audio_shutdown(struct drm_bridge *bridge,
312 struct drm_connector *connecter)
313{
314 struct msm_dp_audio_private *audio;
315 struct msm_dp *msm_dp_display;
316
317 msm_dp_display = to_dp_bridge(bridge)->msm_dp_display;
318 audio = msm_dp_audio_get_data(msm_dp_display);
319 if (IS_ERR(audio)) {
320 DRM_ERROR("failed to get audio data\n");
321 return;
322 }
323
324 /*
325 * if audio was not enabled there is no need
326 * to execute the shutdown and we can bail out early.
327 * This also makes sure that we dont cause an unclocked
328 * access when audio subsystem calls this without DP being
329 * connected. is_connected cannot be used here as its set
330 * to false earlier than this call
331 */
332 if (!msm_dp_display->audio_enabled)
333 return;
334
335 msm_dp_audio_enable(audio, false);
336 /* signal the dp display to safely shutdown clocks */
337 msm_dp_display_signal_audio_complete(msm_dp_display);
338}
339
340struct msm_dp_audio *msm_dp_audio_get(struct platform_device *pdev,
341 void __iomem *link_base)
342{
343 int rc = 0;
344 struct msm_dp_audio_private *audio;
345 struct msm_dp_audio *msm_dp_audio;
346
347 if (!pdev) {
348 DRM_ERROR("invalid input\n");
349 rc = -EINVAL;
350 goto error;
351 }
352
353 audio = devm_kzalloc(&pdev->dev, sizeof(*audio), GFP_KERNEL);
354 if (!audio) {
355 rc = -ENOMEM;
356 goto error;
357 }
358
359 audio->pdev = pdev;
360 audio->link_base = link_base;
361
362 msm_dp_audio = &audio->msm_dp_audio;
363
364 return msm_dp_audio;
365error:
366 return ERR_PTR(rc);
367}
368
369void msm_dp_audio_put(struct msm_dp_audio *msm_dp_audio)
370{
371 struct msm_dp_audio_private *audio;
372
373 if (!msm_dp_audio)
374 return;
375
376 audio = container_of(msm_dp_audio, struct msm_dp_audio_private, msm_dp_audio);
377
378 devm_kfree(&audio->pdev->dev, audio);
379}