projects / openwrt / openwrt.git / blob
? search:


91b2dba7d888e4cfb578b82a580858fd62eb0383
[openwrt/openwrt.git] /
1 From 2a77bbf7f6494d4d618fc6ff70b1a21f04cb8a22 Mon Sep 17 00:00:00 2001
2 From: Sandor Yu <Sandor.yu@nxp.com>
3 Date: Wed, 10 Jul 2019 10:50:25 +0800
4 Subject: [PATCH] drm/rockchip: prepare common code for cdns and rk dpi/dp
5 driver
6
7 - Extracted common fields from cdn_dp_device to a new cdns_mhdp_device
8 structure which will be used by two separate drivers later on.
9 - Moved some datatypes (audio_format, audio_info,
10 vic_pxl_encoding_format, video_info) from cdn-dp-core.c to cdn-dp-reg.h.
11 - Changed prefixes from cdn_dp to cdns_mhdp cdn -> cdns to match the other Cadence's drivers
12 dp -> mhdp to distinguish it from a "just a DP" as the IP underneath this registers map can be a HDMI (which is
13 internally different, but the interface for commands, events is pretty much the same).
14 - Modified cdn-dp-core.c to use the new driver structure and new function names.
15
16 Signed-off-by: Damian Kos<dkos@cadence.com>
17 Reviewed-by: Andrzej Hajda<a.hajda@samsung.com>
18 Signed-off-by: Sandor Yu <Sandor.yu@nxp.com>
19 ---
20 drivers/gpu/drm/rockchip/cdn-dp-core.c | 220 +++++++++--------
21 drivers/gpu/drm/rockchip/cdn-dp-core.h | 40 +---
22 drivers/gpu/drm/rockchip/cdn-dp-reg.c | 415 +++++++++++++++++----------------
23 drivers/gpu/drm/rockchip/cdn-dp-reg.h | 114 +++++++--
24 4 files changed, 423 insertions(+), 366 deletions(-)
25
26 --- a/drivers/gpu/drm/rockchip/cdn-dp-core.c
27 +++ b/drivers/gpu/drm/rockchip/cdn-dp-core.c
28 @@ -22,11 +22,10 @@
29 #include <drm/drm_probe_helper.h>
30
31 #include "cdn-dp-core.h"
32 -#include "cdn-dp-reg.h"
33 #include "rockchip_drm_vop.h"
34
35 #define connector_to_dp(c) \
36 - container_of(c, struct cdn_dp_device, connector)
37 + container_of(c, struct cdn_dp_device, mhdp.connector)
38
39 #define encoder_to_dp(c) \
40 container_of(c, struct cdn_dp_device, encoder)
41 @@ -61,17 +60,18 @@ MODULE_DEVICE_TABLE(of, cdn_dp_dt_ids);
42 static int cdn_dp_grf_write(struct cdn_dp_device *dp,
43 unsigned int reg, unsigned int val)
44 {
45 + struct device *dev = dp->mhdp.dev;
46 int ret;
47
48 ret = clk_prepare_enable(dp->grf_clk);
49 if (ret) {
50 - DRM_DEV_ERROR(dp->dev, "Failed to prepare_enable grf clock\n");
51 + DRM_DEV_ERROR(dev, "Failed to prepare_enable grf clock\n");
52 return ret;
53 }
54
55 ret = regmap_write(dp->grf, reg, val);
56 if (ret) {
57 - DRM_DEV_ERROR(dp->dev, "Could not write to GRF: %d\n", ret);
58 + DRM_DEV_ERROR(dev, "Could not write to GRF: %d\n", ret);
59 clk_disable_unprepare(dp->grf_clk);
60 return ret;
61 }
62 @@ -83,24 +83,25 @@ static int cdn_dp_grf_write(struct cdn_d
63
64 static int cdn_dp_clk_enable(struct cdn_dp_device *dp)
65 {
66 + struct device *dev = dp->mhdp.dev;
67 int ret;
68 unsigned long rate;
69
70 ret = clk_prepare_enable(dp->pclk);
71 if (ret < 0) {
72 - DRM_DEV_ERROR(dp->dev, "cannot enable dp pclk %d\n", ret);
73 + DRM_DEV_ERROR(dev, "cannot enable dp pclk %d\n", ret);
74 goto err_pclk;
75 }
76
77 ret = clk_prepare_enable(dp->core_clk);
78 if (ret < 0) {
79 - DRM_DEV_ERROR(dp->dev, "cannot enable core_clk %d\n", ret);
80 + DRM_DEV_ERROR(dev, "cannot enable core_clk %d\n", ret);
81 goto err_core_clk;
82 }
83
84 - ret = pm_runtime_get_sync(dp->dev);
85 + ret = pm_runtime_get_sync(dev);
86 if (ret < 0) {
87 - DRM_DEV_ERROR(dp->dev, "cannot get pm runtime %d\n", ret);
88 + DRM_DEV_ERROR(dev, "cannot get pm runtime %d\n", ret);
89 goto err_pm_runtime_get;
90 }
91
92 @@ -113,18 +114,18 @@ static int cdn_dp_clk_enable(struct cdn_
93
94 rate = clk_get_rate(dp->core_clk);
95 if (!rate) {
96 - DRM_DEV_ERROR(dp->dev, "get clk rate failed\n");
97 + DRM_DEV_ERROR(dev, "get clk rate failed\n");
98 ret = -EINVAL;
99 goto err_set_rate;
100 }
101
102 - cdn_dp_set_fw_clk(dp, rate);
103 - cdn_dp_clock_reset(dp);
104 + cdns_mhdp_set_fw_clk(&dp->mhdp, rate);
105 + cdns_mhdp_clock_reset(&dp->mhdp);
106
107 return 0;
108
109 err_set_rate:
110 - pm_runtime_put(dp->dev);
111 + pm_runtime_put(dev);
112 err_pm_runtime_get:
113 clk_disable_unprepare(dp->core_clk);
114 err_core_clk:
115 @@ -135,7 +136,7 @@ err_pclk:
116
117 static void cdn_dp_clk_disable(struct cdn_dp_device *dp)
118 {
119 - pm_runtime_put_sync(dp->dev);
120 + pm_runtime_put_sync(dp->mhdp.dev);
121 clk_disable_unprepare(dp->pclk);
122 clk_disable_unprepare(dp->core_clk);
123 }
124 @@ -168,7 +169,7 @@ static int cdn_dp_get_sink_count(struct
125 u8 value;
126
127 *sink_count = 0;
128 - ret = cdn_dp_dpcd_read(dp, DP_SINK_COUNT, &value, 1);
129 + ret = cdns_mhdp_dpcd_read(&dp->mhdp, DP_SINK_COUNT, &value, 1);
130 if (ret)
131 return ret;
132
133 @@ -192,12 +193,13 @@ static struct cdn_dp_port *cdn_dp_connec
134
135 static bool cdn_dp_check_sink_connection(struct cdn_dp_device *dp)
136 {
137 + struct device *dev = dp->mhdp.dev;
138 unsigned long timeout = jiffies + msecs_to_jiffies(CDN_DPCD_TIMEOUT_MS);
139 struct cdn_dp_port *port;
140 u8 sink_count = 0;
141
142 if (dp->active_port < 0 || dp->active_port >= dp->ports) {
143 - DRM_DEV_ERROR(dp->dev, "active_port is wrong!\n");
144 + DRM_DEV_ERROR(dev, "active_port is wrong!\n");
145 return false;
146 }
147
148 @@ -219,7 +221,7 @@ static bool cdn_dp_check_sink_connection
149 usleep_range(5000, 10000);
150 }
151
152 - DRM_DEV_ERROR(dp->dev, "Get sink capability timed out\n");
153 + DRM_DEV_ERROR(dev, "Get sink capability timed out\n");
154 return false;
155 }
156
157 @@ -261,7 +263,8 @@ static int cdn_dp_connector_get_modes(st
158 mutex_lock(&dp->lock);
159 edid = dp->edid;
160 if (edid) {
161 - DRM_DEV_DEBUG_KMS(dp->dev, "got edid: width[%d] x height[%d]\n",
162 + DRM_DEV_DEBUG_KMS(dp->mhdp.dev,
163 + "got edid: width[%d] x height[%d]\n",
164 edid->width_cm, edid->height_cm);
165
166 dp->sink_has_audio = drm_detect_monitor_audio(edid);
167 @@ -280,7 +283,8 @@ cdn_dp_connector_mode_valid(struct drm_c
168 struct drm_display_mode *mode)
169 {
170 struct cdn_dp_device *dp = connector_to_dp(connector);
171 - struct drm_display_info *display_info = &dp->connector.display_info;
172 + struct drm_display_info *display_info =
173 + &dp->mhdp.connector.display_info;
174 u32 requested, actual, rate, sink_max, source_max = 0;
175 u8 lanes, bpc;
176
177 @@ -306,7 +310,7 @@ cdn_dp_connector_mode_valid(struct drm_c
178 sink_max = drm_dp_max_lane_count(dp->dpcd);
179 lanes = min(source_max, sink_max);
180
181 - source_max = drm_dp_bw_code_to_link_rate(CDN_DP_MAX_LINK_RATE);
182 + source_max = drm_dp_bw_code_to_link_rate(CDNS_DP_MAX_LINK_RATE);
183 sink_max = drm_dp_max_link_rate(dp->dpcd);
184 rate = min(source_max, sink_max);
185
186 @@ -316,7 +320,7 @@ cdn_dp_connector_mode_valid(struct drm_c
187 actual = actual * 8 / 10;
188
189 if (requested > actual) {
190 - DRM_DEV_DEBUG_KMS(dp->dev,
191 + DRM_DEV_DEBUG_KMS(dp->mhdp.dev,
192 "requested=%d, actual=%d, clock=%d\n",
193 requested, actual, mode->clock);
194 return MODE_CLOCK_HIGH;
195 @@ -336,28 +340,29 @@ static int cdn_dp_firmware_init(struct c
196 const u32 *iram_data, *dram_data;
197 const struct firmware *fw = dp->fw;
198 const struct cdn_firmware_header *hdr;
199 + struct device *dev = dp->mhdp.dev;
200
201 hdr = (struct cdn_firmware_header *)fw->data;
202 if (fw->size != le32_to_cpu(hdr->size_bytes)) {
203 - DRM_DEV_ERROR(dp->dev, "firmware is invalid\n");
204 + DRM_DEV_ERROR(dev, "firmware is invalid\n");
205 return -EINVAL;
206 }
207
208 iram_data = (const u32 *)(fw->data + hdr->header_size);
209 dram_data = (const u32 *)(fw->data + hdr->header_size + hdr->iram_size);
210
211 - ret = cdn_dp_load_firmware(dp, iram_data, hdr->iram_size,
212 - dram_data, hdr->dram_size);
213 + ret = cdns_mhdp_load_firmware(&dp->mhdp, iram_data, hdr->iram_size,
214 + dram_data, hdr->dram_size);
215 if (ret)
216 return ret;
217
218 - ret = cdn_dp_set_firmware_active(dp, true);
219 + ret = cdns_mhdp_set_firmware_active(&dp->mhdp, true);
220 if (ret) {
221 - DRM_DEV_ERROR(dp->dev, "active ucpu failed: %d\n", ret);
222 + DRM_DEV_ERROR(dev, "active ucpu failed: %d\n", ret);
223 return ret;
224 }
225
226 - return cdn_dp_event_config(dp);
227 + return cdns_mhdp_event_config(&dp->mhdp);
228 }
229
230 static int cdn_dp_get_sink_capability(struct cdn_dp_device *dp)
231 @@ -367,28 +372,29 @@ static int cdn_dp_get_sink_capability(st
232 if (!cdn_dp_check_sink_connection(dp))
233 return -ENODEV;
234
235 - ret = cdn_dp_dpcd_read(dp, DP_DPCD_REV, dp->dpcd,
236 - DP_RECEIVER_CAP_SIZE);
237 + ret = cdns_mhdp_dpcd_read(&dp->mhdp, DP_DPCD_REV, dp->dpcd,
238 + DP_RECEIVER_CAP_SIZE);
239 if (ret) {
240 - DRM_DEV_ERROR(dp->dev, "Failed to get caps %d\n", ret);
241 + DRM_DEV_ERROR(dp->mhdp.dev, "Failed to get caps %d\n", ret);
242 return ret;
243 }
244
245 kfree(dp->edid);
246 - dp->edid = drm_do_get_edid(&dp->connector,
247 - cdn_dp_get_edid_block, dp);
248 + dp->edid = drm_do_get_edid(&dp->mhdp.connector,
249 + cdns_mhdp_get_edid_block, &dp->mhdp);
250 return 0;
251 }
252
253 static int cdn_dp_enable_phy(struct cdn_dp_device *dp, struct cdn_dp_port *port)
254 {
255 + struct device *dev = dp->mhdp.dev;
256 union extcon_property_value property;
257 int ret;
258
259 if (!port->phy_enabled) {
260 ret = phy_power_on(port->phy);
261 if (ret) {
262 - DRM_DEV_ERROR(dp->dev, "phy power on failed: %d\n",
263 + DRM_DEV_ERROR(dev, "phy power on failed: %d\n",
264 ret);
265 goto err_phy;
266 }
267 @@ -398,28 +404,28 @@ static int cdn_dp_enable_phy(struct cdn_
268 ret = cdn_dp_grf_write(dp, GRF_SOC_CON26,
269 DPTX_HPD_SEL_MASK | DPTX_HPD_SEL);
270 if (ret) {
271 - DRM_DEV_ERROR(dp->dev, "Failed to write HPD_SEL %d\n", ret);
272 + DRM_DEV_ERROR(dev, "Failed to write HPD_SEL %d\n", ret);
273 goto err_power_on;
274 }
275
276 - ret = cdn_dp_get_hpd_status(dp);
277 + ret = cdns_mhdp_get_hpd_status(&dp->mhdp);
278 if (ret <= 0) {
279 if (!ret)
280 - DRM_DEV_ERROR(dp->dev, "hpd does not exist\n");
281 + DRM_DEV_ERROR(dev, "hpd does not exist\n");
282 goto err_power_on;
283 }
284
285 ret = extcon_get_property(port->extcon, EXTCON_DISP_DP,
286 EXTCON_PROP_USB_TYPEC_POLARITY, &property);
287 if (ret) {
288 - DRM_DEV_ERROR(dp->dev, "get property failed\n");
289 + DRM_DEV_ERROR(dev, "get property failed\n");
290 goto err_power_on;
291 }
292
293 port->lanes = cdn_dp_get_port_lanes(port);
294 - ret = cdn_dp_set_host_cap(dp, port->lanes, property.intval);
295 + ret = cdns_mhdp_set_host_cap(&dp->mhdp, port->lanes, property.intval);
296 if (ret) {
297 - DRM_DEV_ERROR(dp->dev, "set host capabilities failed: %d\n",
298 + DRM_DEV_ERROR(dev, "set host capabilities failed: %d\n",
299 ret);
300 goto err_power_on;
301 }
302 @@ -429,7 +435,7 @@ static int cdn_dp_enable_phy(struct cdn_
303
304 err_power_on:
305 if (phy_power_off(port->phy))
306 - DRM_DEV_ERROR(dp->dev, "phy power off failed: %d", ret);
307 + DRM_DEV_ERROR(dev, "phy power off failed: %d", ret);
308 else
309 port->phy_enabled = false;
310
311 @@ -447,7 +453,8 @@ static int cdn_dp_disable_phy(struct cdn
312 if (port->phy_enabled) {
313 ret = phy_power_off(port->phy);
314 if (ret) {
315 - DRM_DEV_ERROR(dp->dev, "phy power off failed: %d", ret);
316 + DRM_DEV_ERROR(dp->mhdp.dev,
317 + "phy power off failed: %d", ret);
318 return ret;
319 }
320 }
321 @@ -471,16 +478,16 @@ static int cdn_dp_disable(struct cdn_dp_
322 ret = cdn_dp_grf_write(dp, GRF_SOC_CON26,
323 DPTX_HPD_SEL_MASK | DPTX_HPD_DEL);
324 if (ret) {
325 - DRM_DEV_ERROR(dp->dev, "Failed to clear hpd sel %d\n",
326 + DRM_DEV_ERROR(dp->mhdp.dev, "Failed to clear hpd sel %d\n",
327 ret);
328 return ret;
329 }
330
331 - cdn_dp_set_firmware_active(dp, false);
332 + cdns_mhdp_set_firmware_active(&dp->mhdp, false);
333 cdn_dp_clk_disable(dp);
334 dp->active = false;
335 - dp->link.rate = 0;
336 - dp->link.num_lanes = 0;
337 + dp->mhdp.link.rate = 0;
338 + dp->mhdp.link.num_lanes = 0;
339 if (!dp->connected) {
340 kfree(dp->edid);
341 dp->edid = NULL;
342 @@ -493,11 +500,11 @@ static int cdn_dp_enable(struct cdn_dp_d
343 {
344 int ret, i, lanes;
345 struct cdn_dp_port *port;
346 + struct device *dev = dp->mhdp.dev;
347
348 port = cdn_dp_connected_port(dp);
349 if (!port) {
350 - DRM_DEV_ERROR(dp->dev,
351 - "Can't enable without connection\n");
352 + DRM_DEV_ERROR(dev, "Can't enable without connection\n");
353 return -ENODEV;
354 }
355
356 @@ -510,7 +517,7 @@ static int cdn_dp_enable(struct cdn_dp_d
357
358 ret = cdn_dp_firmware_init(dp);
359 if (ret) {
360 - DRM_DEV_ERROR(dp->dev, "firmware init failed: %d", ret);
361 + DRM_DEV_ERROR(dp->mhdp.dev, "firmware init failed: %d", ret);
362 goto err_clk_disable;
363 }
364
365 @@ -544,8 +551,9 @@ static void cdn_dp_encoder_mode_set(stru
366 struct drm_display_mode *adjusted)
367 {
368 struct cdn_dp_device *dp = encoder_to_dp(encoder);
369 - struct drm_display_info *display_info = &dp->connector.display_info;
370 - struct video_info *video = &dp->video_info;
371 + struct drm_display_info *display_info =
372 + &dp->mhdp.connector.display_info;
373 + struct video_info *video = &dp->mhdp.video_info;
374
375 switch (display_info->bpc) {
376 case 10:
377 @@ -563,7 +571,7 @@ static void cdn_dp_encoder_mode_set(stru
378 video->v_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NVSYNC);
379 video->h_sync_polarity = !!(mode->flags & DRM_MODE_FLAG_NHSYNC);
380
381 - memcpy(&dp->mode, adjusted, sizeof(*mode));
382 + memcpy(&dp->mhdp.mode, adjusted, sizeof(*mode));
383 }
384
385 static bool cdn_dp_check_link_status(struct cdn_dp_device *dp)
386 @@ -572,11 +580,11 @@ static bool cdn_dp_check_link_status(str
387 struct cdn_dp_port *port = cdn_dp_connected_port(dp);
388 u8 sink_lanes = drm_dp_max_lane_count(dp->dpcd);
389
390 - if (!port || !dp->link.rate || !dp->link.num_lanes)
391 + if (!port || !dp->mhdp.link.rate || !dp->mhdp.link.num_lanes)
392 return false;
393
394 - if (cdn_dp_dpcd_read(dp, DP_LANE0_1_STATUS, link_status,
395 - DP_LINK_STATUS_SIZE)) {
396 + if (cdns_mhdp_dpcd_read(&dp->mhdp, DP_LANE0_1_STATUS, link_status,
397 + DP_LINK_STATUS_SIZE)) {
398 DRM_ERROR("Failed to get link status\n");
399 return false;
400 }
401 @@ -588,15 +596,16 @@ static bool cdn_dp_check_link_status(str
402 static void cdn_dp_encoder_enable(struct drm_encoder *encoder)
403 {
404 struct cdn_dp_device *dp = encoder_to_dp(encoder);
405 + struct device *dev = dp->mhdp.dev;
406 int ret, val;
407
408 - ret = drm_of_encoder_active_endpoint_id(dp->dev->of_node, encoder);
409 + ret = drm_of_encoder_active_endpoint_id(dev->of_node, encoder);
410 if (ret < 0) {
411 - DRM_DEV_ERROR(dp->dev, "Could not get vop id, %d", ret);
412 + DRM_DEV_ERROR(dev, "Could not get vop id, %d", ret);
413 return;
414 }
415
416 - DRM_DEV_DEBUG_KMS(dp->dev, "vop %s output to cdn-dp\n",
417 + DRM_DEV_DEBUG_KMS(dev, "vop %s output to cdn-dp\n",
418 (ret) ? "LIT" : "BIG");
419 if (ret)
420 val = DP_SEL_VOP_LIT | (DP_SEL_VOP_LIT << 16);
421 @@ -611,33 +620,33 @@ static void cdn_dp_encoder_enable(struct
422
423 ret = cdn_dp_enable(dp);
424 if (ret) {
425 - DRM_DEV_ERROR(dp->dev, "Failed to enable encoder %d\n",
426 + DRM_DEV_ERROR(dev, "Failed to enable encoder %d\n",
427 ret);
428 goto out;
429 }
430 if (!cdn_dp_check_link_status(dp)) {
431 - ret = cdn_dp_train_link(dp);
432 + ret = cdns_mhdp_train_link(&dp->mhdp);
433 if (ret) {
434 - DRM_DEV_ERROR(dp->dev, "Failed link train %d\n", ret);
435 + DRM_DEV_ERROR(dev, "Failed link train %d\n", ret);
436 goto out;
437 }
438 }
439
440 - ret = cdn_dp_set_video_status(dp, CONTROL_VIDEO_IDLE);
441 + ret = cdns_mhdp_set_video_status(&dp->mhdp, CONTROL_VIDEO_IDLE);
442 if (ret) {
443 - DRM_DEV_ERROR(dp->dev, "Failed to idle video %d\n", ret);
444 + DRM_DEV_ERROR(dev, "Failed to idle video %d\n", ret);
445 goto out;
446 }
447
448 - ret = cdn_dp_config_video(dp);
449 + ret = cdns_mhdp_config_video(&dp->mhdp);
450 if (ret) {
451 - DRM_DEV_ERROR(dp->dev, "Failed to config video %d\n", ret);
452 + DRM_DEV_ERROR(dev, "Failed to config video %d\n", ret);
453 goto out;
454 }
455
456 - ret = cdn_dp_set_video_status(dp, CONTROL_VIDEO_VALID);
457 + ret = cdns_mhdp_set_video_status(&dp->mhdp, CONTROL_VIDEO_VALID);
458 if (ret) {
459 - DRM_DEV_ERROR(dp->dev, "Failed to valid video %d\n", ret);
460 + DRM_DEV_ERROR(dev, "Failed to valid video %d\n", ret);
461 goto out;
462 }
463 out:
464 @@ -653,7 +662,8 @@ static void cdn_dp_encoder_disable(struc
465 if (dp->active) {
466 ret = cdn_dp_disable(dp);
467 if (ret) {
468 - DRM_DEV_ERROR(dp->dev, "Failed to disable encoder %d\n",
469 + DRM_DEV_ERROR(dp->mhdp.dev,
470 + "Failed to disable encoder %d\n",
471 ret);
472 }
473 }
474 @@ -697,7 +707,7 @@ static const struct drm_encoder_funcs cd
475
476 static int cdn_dp_parse_dt(struct cdn_dp_device *dp)
477 {
478 - struct device *dev = dp->dev;
479 + struct device *dev = dp->mhdp.dev;
480 struct device_node *np = dev->of_node;
481 struct platform_device *pdev = to_platform_device(dev);
482 struct resource *res;
483 @@ -709,10 +719,10 @@ static int cdn_dp_parse_dt(struct cdn_dp
484 }
485
486 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
487 - dp->regs = devm_ioremap_resource(dev, res);
488 - if (IS_ERR(dp->regs)) {
489 + dp->mhdp.regs = devm_ioremap_resource(dev, res);
490 + if (IS_ERR(dp->mhdp.regs)) {
491 DRM_DEV_ERROR(dev, "ioremap reg failed\n");
492 - return PTR_ERR(dp->regs);
493 + return PTR_ERR(dp->mhdp.regs);
494 }
495
496 dp->core_clk = devm_clk_get(dev, "core-clk");
497 @@ -727,10 +737,10 @@ static int cdn_dp_parse_dt(struct cdn_dp
498 return PTR_ERR(dp->pclk);
499 }
500
501 - dp->spdif_clk = devm_clk_get(dev, "spdif");
502 - if (IS_ERR(dp->spdif_clk)) {
503 + dp->mhdp.spdif_clk = devm_clk_get(dev, "spdif");
504 + if (IS_ERR(dp->mhdp.spdif_clk)) {
505 DRM_DEV_ERROR(dev, "cannot get spdif_clk\n");
506 - return PTR_ERR(dp->spdif_clk);
507 + return PTR_ERR(dp->mhdp.spdif_clk);
508 }
509
510 dp->grf_clk = devm_clk_get(dev, "grf");
511 @@ -739,10 +749,10 @@ static int cdn_dp_parse_dt(struct cdn_dp
512 return PTR_ERR(dp->grf_clk);
513 }
514
515 - dp->spdif_rst = devm_reset_control_get(dev, "spdif");
516 - if (IS_ERR(dp->spdif_rst)) {
517 + dp->mhdp.spdif_rst = devm_reset_control_get(dev, "spdif");
518 + if (IS_ERR(dp->mhdp.spdif_rst)) {
519 DRM_DEV_ERROR(dev, "no spdif reset control found\n");
520 - return PTR_ERR(dp->spdif_rst);
521 + return PTR_ERR(dp->mhdp.spdif_rst);
522 }
523
524 dp->dptx_rst = devm_reset_control_get(dev, "dptx");
525 @@ -797,7 +807,7 @@ static int cdn_dp_audio_hw_params(struct
526 goto out;
527 }
528
529 - ret = cdn_dp_audio_config(dp, &audio);
530 + ret = cdns_mhdp_audio_config(&dp->mhdp, &audio);
531 if (!ret)
532 dp->audio_info = audio;
533
534 @@ -815,7 +825,7 @@ static void cdn_dp_audio_shutdown(struct
535 if (!dp->active)
536 goto out;
537
538 - ret = cdn_dp_audio_stop(dp, &dp->audio_info);
539 + ret = cdns_mhdp_audio_stop(&dp->mhdp, &dp->audio_info);
540 if (!ret)
541 dp->audio_info.format = AFMT_UNUSED;
542 out:
543 @@ -834,7 +844,7 @@ static int cdn_dp_audio_digital_mute(str
544 goto out;
545 }
546
547 - ret = cdn_dp_audio_mute(dp, enable);
548 + ret = cdns_mhdp_audio_mute(&dp->mhdp, enable);
549
550 out:
551 mutex_unlock(&dp->lock);
552 @@ -846,7 +856,8 @@ static int cdn_dp_audio_get_eld(struct d
553 {
554 struct cdn_dp_device *dp = dev_get_drvdata(dev);
555
556 - memcpy(buf, dp->connector.eld, min(sizeof(dp->connector.eld), len));
557 + memcpy(buf, dp->mhdp.connector.eld,
558 + min(sizeof(dp->mhdp.connector.eld), len));
559
560 return 0;
561 }
562 @@ -880,6 +891,7 @@ static int cdn_dp_request_firmware(struc
563 int ret;
564 unsigned long timeout = jiffies + msecs_to_jiffies(CDN_FW_TIMEOUT_MS);
565 unsigned long sleep = 1000;
566 + struct device *dev = dp->mhdp.dev;
567
568 WARN_ON(!mutex_is_locked(&dp->lock));
569
570 @@ -890,13 +902,13 @@ static int cdn_dp_request_firmware(struc
571 mutex_unlock(&dp->lock);
572
573 while (time_before(jiffies, timeout)) {
574 - ret = request_firmware(&dp->fw, CDN_DP_FIRMWARE, dp->dev);
575 + ret = request_firmware(&dp->fw, CDN_DP_FIRMWARE, dev);
576 if (ret == -ENOENT) {
577 msleep(sleep);
578 sleep *= 2;
579 continue;
580 } else if (ret) {
581 - DRM_DEV_ERROR(dp->dev,
582 + DRM_DEV_ERROR(dev,
583 "failed to request firmware: %d\n", ret);
584 goto out;
585 }
586 @@ -906,7 +918,7 @@ static int cdn_dp_request_firmware(struc
587 goto out;
588 }
589
590 - DRM_DEV_ERROR(dp->dev, "Timed out trying to load firmware\n");
591 + DRM_DEV_ERROR(dev, "Timed out trying to load firmware\n");
592 ret = -ETIMEDOUT;
593 out:
594 mutex_lock(&dp->lock);
595 @@ -917,8 +929,9 @@ static void cdn_dp_pd_event_work(struct
596 {
597 struct cdn_dp_device *dp = container_of(work, struct cdn_dp_device,
598 event_work);
599 - struct drm_connector *connector = &dp->connector;
600 + struct drm_connector *connector = &dp->mhdp.connector;
601 enum drm_connector_status old_status;
602 + struct device *dev = dp->mhdp.dev;
603
604 int ret;
605
606 @@ -935,44 +948,45 @@ static void cdn_dp_pd_event_work(struct
607
608 /* Not connected, notify userspace to disable the block */
609 if (!cdn_dp_connected_port(dp)) {
610 - DRM_DEV_INFO(dp->dev, "Not connected. Disabling cdn\n");
611 + DRM_DEV_INFO(dev, "Not connected. Disabling cdn\n");
612 dp->connected = false;
613
614 /* Connected but not enabled, enable the block */
615 } else if (!dp->active) {
616 - DRM_DEV_INFO(dp->dev, "Connected, not enabled. Enabling cdn\n");
617 + DRM_DEV_INFO(dev, "Connected, not enabled. Enabling cdn\n");
618 ret = cdn_dp_enable(dp);
619 if (ret) {
620 - DRM_DEV_ERROR(dp->dev, "Enable dp failed %d\n", ret);
621 + DRM_DEV_ERROR(dev, "Enable dp failed %d\n", ret);
622 dp->connected = false;
623 }
624
625 /* Enabled and connected to a dongle without a sink, notify userspace */
626 } else if (!cdn_dp_check_sink_connection(dp)) {
627 - DRM_DEV_INFO(dp->dev, "Connected without sink. Assert hpd\n");
628 + DRM_DEV_INFO(dev, "Connected without sink. Assert hpd\n");
629 dp->connected = false;
630
631 /* Enabled and connected with a sink, re-train if requested */
632 } else if (!cdn_dp_check_link_status(dp)) {
633 - unsigned int rate = dp->link.rate;
634 - unsigned int lanes = dp->link.num_lanes;
635 - struct drm_display_mode *mode = &dp->mode;
636 + unsigned int rate = dp->mhdp.link.rate;
637 + unsigned int lanes = dp->mhdp.link.num_lanes;
638 + struct drm_display_mode *mode = &dp->mhdp.mode;
639
640 - DRM_DEV_INFO(dp->dev, "Connected with sink. Re-train link\n");
641 - ret = cdn_dp_train_link(dp);
642 + DRM_DEV_INFO(dev, "Connected with sink. Re-train link\n");
643 + ret = cdns_mhdp_train_link(&dp->mhdp);
644 if (ret) {
645 dp->connected = false;
646 - DRM_DEV_ERROR(dp->dev, "Train link failed %d\n", ret);
647 + DRM_DEV_ERROR(dev, "Train link failed %d\n", ret);
648 goto out;
649 }
650
651 /* If training result is changed, update the video config */
652 if (mode->clock &&
653 - (rate != dp->link.rate || lanes != dp->link.num_lanes)) {
654 - ret = cdn_dp_config_video(dp);
655 + (rate != dp->mhdp.link.rate ||
656 + lanes != dp->mhdp.link.num_lanes)) {
657 + ret = cdns_mhdp_config_video(&dp->mhdp);
658 if (ret) {
659 dp->connected = false;
660 - DRM_DEV_ERROR(dp->dev,
661 + DRM_DEV_ERROR(dev,
662 "Failed to config video %d\n",
663 ret);
664 }
665 @@ -1041,7 +1055,7 @@ static int cdn_dp_bind(struct device *de
666
667 drm_encoder_helper_add(encoder, &cdn_dp_encoder_helper_funcs);
668
669 - connector = &dp->connector;
670 + connector = &dp->mhdp.connector;
671 connector->polled = DRM_CONNECTOR_POLL_HPD;
672 connector->dpms = DRM_MODE_DPMS_OFF;
673
674 @@ -1065,7 +1079,7 @@ static int cdn_dp_bind(struct device *de
675 port = dp->port[i];
676
677 port->event_nb.notifier_call = cdn_dp_pd_event;
678 - ret = devm_extcon_register_notifier(dp->dev, port->extcon,
679 + ret = devm_extcon_register_notifier(dp->mhdp.dev, port->extcon,
680 EXTCON_DISP_DP,
681 &port->event_nb);
682 if (ret) {
683 @@ -1092,7 +1106,7 @@ static void cdn_dp_unbind(struct device
684 {
685 struct cdn_dp_device *dp = dev_get_drvdata(dev);
686 struct drm_encoder *encoder = &dp->encoder;
687 - struct drm_connector *connector = &dp->connector;
688 + struct drm_connector *connector = &dp->mhdp.connector;
689
690 cancel_work_sync(&dp->event_work);
691 cdn_dp_encoder_disable(encoder);
692 @@ -1152,7 +1166,7 @@ static int cdn_dp_probe(struct platform_
693 dp = devm_kzalloc(dev, sizeof(*dp), GFP_KERNEL);
694 if (!dp)
695 return -ENOMEM;
696 - dp->dev = dev;
697 + dp->mhdp.dev = dev;
698
699 match = of_match_node(cdn_dp_dt_ids, pdev->dev.of_node);
700 dp_data = (struct cdn_dp_data *)match->data;
701 @@ -1197,7 +1211,7 @@ static int cdn_dp_remove(struct platform
702 struct cdn_dp_device *dp = platform_get_drvdata(pdev);
703
704 platform_device_unregister(dp->audio_pdev);
705 - cdn_dp_suspend(dp->dev);
706 + cdn_dp_suspend(dp->mhdp.dev);
707 component_del(&pdev->dev, &cdn_dp_component_ops);
708
709 return 0;
710 @@ -1207,7 +1221,7 @@ static void cdn_dp_shutdown(struct platf
711 {
712 struct cdn_dp_device *dp = platform_get_drvdata(pdev);
713
714 - cdn_dp_suspend(dp->dev);
715 + cdn_dp_suspend(dp->mhdp.dev);
716 }
717
718 static const struct dev_pm_ops cdn_dp_pm_ops = {
719 --- a/drivers/gpu/drm/rockchip/cdn-dp-core.h
720 +++ b/drivers/gpu/drm/rockchip/cdn-dp-core.h
721 @@ -12,38 +12,10 @@
722 #include <drm/drm_probe_helper.h>
723
724 #include "rockchip_drm_drv.h"
725 +#include "cdn-dp-reg.h"
726
727 #define MAX_PHY 2
728
729 -enum audio_format {
730 - AFMT_I2S = 0,
731 - AFMT_SPDIF = 1,
732 - AFMT_UNUSED,
733 -};
734 -
735 -struct audio_info {
736 - enum audio_format format;
737 - int sample_rate;
738 - int channels;
739 - int sample_width;
740 -};
741 -
742 -enum vic_pxl_encoding_format {
743 - PXL_RGB = 0x1,
744 - YCBCR_4_4_4 = 0x2,
745 - YCBCR_4_2_2 = 0x4,
746 - YCBCR_4_2_0 = 0x8,
747 - Y_ONLY = 0x10,
748 -};
749 -
750 -struct video_info {
751 - bool h_sync_polarity;
752 - bool v_sync_polarity;
753 - bool interlaced;
754 - int color_depth;
755 - enum vic_pxl_encoding_format color_fmt;
756 -};
757 -
758 struct cdn_firmware_header {
759 u32 size_bytes; /* size of the entire header+image(s) in bytes */
760 u32 header_size; /* size of just the header in bytes */
761 @@ -62,11 +34,9 @@ struct cdn_dp_port {
762 };
763
764 struct cdn_dp_device {
765 - struct device *dev;
766 + struct cdns_mhdp_device mhdp;
767 struct drm_device *drm_dev;
768 - struct drm_connector connector;
769 struct drm_encoder encoder;
770 - struct drm_display_mode mode;
771 struct platform_device *audio_pdev;
772 struct work_struct event_work;
773 struct edid *edid;
774 @@ -77,22 +47,16 @@ struct cdn_dp_device {
775 bool suspended;
776
777 const struct firmware *fw; /* cdn dp firmware */
778 - unsigned int fw_version; /* cdn fw version */
779 bool fw_loaded;
780
781 - void __iomem *regs;
782 struct regmap *grf;
783 struct clk *core_clk;
784 struct clk *pclk;
785 - struct clk *spdif_clk;
786 struct clk *grf_clk;
787 - struct reset_control *spdif_rst;
788 struct reset_control *dptx_rst;
789 struct reset_control *apb_rst;
790 struct reset_control *core_rst;
791 struct audio_info audio_info;
792 - struct video_info video_info;
793 - struct drm_dp_link link;
794 struct cdn_dp_port *port[MAX_PHY];
795 u8 ports;
796 u8 lanes;
797 --- a/drivers/gpu/drm/rockchip/cdn-dp-reg.c
798 +++ b/drivers/gpu/drm/rockchip/cdn-dp-reg.c
799 @@ -14,19 +14,19 @@
800 #include "cdn-dp-core.h"
801 #include "cdn-dp-reg.h"
802
803 -#define CDN_DP_SPDIF_CLK 200000000
804 +#define CDNS_DP_SPDIF_CLK 200000000
805 #define FW_ALIVE_TIMEOUT_US 1000000
806 #define MAILBOX_RETRY_US 1000
807 #define MAILBOX_TIMEOUT_US 5000000
808 #define LINK_TRAINING_RETRY_MS 20
809 #define LINK_TRAINING_TIMEOUT_MS 500
810
811 -void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, unsigned long clk)
812 +void cdns_mhdp_set_fw_clk(struct cdns_mhdp_device *mhdp, unsigned long clk)
813 {
814 - writel(clk / 1000000, dp->regs + SW_CLK_H);
815 + writel(clk / 1000000, mhdp->regs + SW_CLK_H);
816 }
817
818 -void cdn_dp_clock_reset(struct cdn_dp_device *dp)
819 +void cdns_mhdp_clock_reset(struct cdns_mhdp_device *mhdp)
820 {
821 u32 val;
822
823 @@ -42,16 +42,16 @@ void cdn_dp_clock_reset(struct cdn_dp_de
824 DPTX_SYS_CLK_EN |
825 CFG_DPTX_VIF_CLK_RSTN_EN |
826 CFG_DPTX_VIF_CLK_EN;
827 - writel(val, dp->regs + SOURCE_DPTX_CAR);
828 + writel(val, mhdp->regs + SOURCE_DPTX_CAR);
829
830 val = SOURCE_PHY_RSTN_EN | SOURCE_PHY_CLK_EN;
831 - writel(val, dp->regs + SOURCE_PHY_CAR);
832 + writel(val, mhdp->regs + SOURCE_PHY_CAR);
833
834 val = SOURCE_PKT_SYS_RSTN_EN |
835 SOURCE_PKT_SYS_CLK_EN |
836 SOURCE_PKT_DATA_RSTN_EN |
837 SOURCE_PKT_DATA_CLK_EN;
838 - writel(val, dp->regs + SOURCE_PKT_CAR);
839 + writel(val, mhdp->regs + SOURCE_PKT_CAR);
840
841 val = SPDIF_CDR_CLK_RSTN_EN |
842 SPDIF_CDR_CLK_EN |
843 @@ -59,53 +59,53 @@ void cdn_dp_clock_reset(struct cdn_dp_de
844 SOURCE_AIF_SYS_CLK_EN |
845 SOURCE_AIF_CLK_RSTN_EN |
846 SOURCE_AIF_CLK_EN;
847 - writel(val, dp->regs + SOURCE_AIF_CAR);
848 + writel(val, mhdp->regs + SOURCE_AIF_CAR);
849
850 val = SOURCE_CIPHER_SYSTEM_CLK_RSTN_EN |
851 SOURCE_CIPHER_SYS_CLK_EN |
852 SOURCE_CIPHER_CHAR_CLK_RSTN_EN |
853 SOURCE_CIPHER_CHAR_CLK_EN;
854 - writel(val, dp->regs + SOURCE_CIPHER_CAR);
855 + writel(val, mhdp->regs + SOURCE_CIPHER_CAR);
856
857 val = SOURCE_CRYPTO_SYS_CLK_RSTN_EN |
858 SOURCE_CRYPTO_SYS_CLK_EN;
859 - writel(val, dp->regs + SOURCE_CRYPTO_CAR);
860 + writel(val, mhdp->regs + SOURCE_CRYPTO_CAR);
861
862 /* enable Mailbox and PIF interrupt */
863 - writel(0, dp->regs + APB_INT_MASK);
864 + writel(0, mhdp->regs + APB_INT_MASK);
865 }
866
867 -static int cdn_dp_mailbox_read(struct cdn_dp_device *dp)
868 +static int cdns_mhdp_mailbox_read(struct cdns_mhdp_device *mhdp)
869 {
870 int val, ret;
871
872 - ret = readx_poll_timeout(readl, dp->regs + MAILBOX_EMPTY_ADDR,
873 + ret = readx_poll_timeout(readl, mhdp->regs + MAILBOX_EMPTY_ADDR,
874 val, !val, MAILBOX_RETRY_US,
875 MAILBOX_TIMEOUT_US);
876 if (ret < 0)
877 return ret;
878
879 - return readl(dp->regs + MAILBOX0_RD_DATA) & 0xff;
880 + return readl(mhdp->regs + MAILBOX0_RD_DATA) & 0xff;
881 }
882
883 -static int cdp_dp_mailbox_write(struct cdn_dp_device *dp, u8 val)
884 +static int cdp_dp_mailbox_write(struct cdns_mhdp_device *mhdp, u8 val)
885 {
886 int ret, full;
887
888 - ret = readx_poll_timeout(readl, dp->regs + MAILBOX_FULL_ADDR,
889 + ret = readx_poll_timeout(readl, mhdp->regs + MAILBOX_FULL_ADDR,
890 full, !full, MAILBOX_RETRY_US,
891 MAILBOX_TIMEOUT_US);
892 if (ret < 0)
893 return ret;
894
895 - writel(val, dp->regs + MAILBOX0_WR_DATA);
896 + writel(val, mhdp->regs + MAILBOX0_WR_DATA);
897
898 return 0;
899 }
900
901 -static int cdn_dp_mailbox_validate_receive(struct cdn_dp_device *dp,
902 - u8 module_id, u8 opcode,
903 - u16 req_size)
904 +static int cdns_mhdp_mailbox_validate_receive(struct cdns_mhdp_device *mhdp,
905 + u8 module_id, u8 opcode,
906 + u16 req_size)
907 {
908 u32 mbox_size, i;
909 u8 header[4];
910 @@ -113,7 +113,7 @@ static int cdn_dp_mailbox_validate_recei
911
912 /* read the header of the message */
913 for (i = 0; i < 4; i++) {
914 - ret = cdn_dp_mailbox_read(dp);
915 + ret = cdns_mhdp_mailbox_read(mhdp);
916 if (ret < 0)
917 return ret;
918
919 @@ -129,7 +129,7 @@ static int cdn_dp_mailbox_validate_recei
920 * clear the mailbox by reading its contents.
921 */
922 for (i = 0; i < mbox_size; i++)
923 - if (cdn_dp_mailbox_read(dp) < 0)
924 + if (cdns_mhdp_mailbox_read(mhdp) < 0)
925 break;
926
927 return -EINVAL;
928 @@ -138,14 +138,14 @@ static int cdn_dp_mailbox_validate_recei
929 return 0;
930 }
931
932 -static int cdn_dp_mailbox_read_receive(struct cdn_dp_device *dp,
933 - u8 *buff, u16 buff_size)
934 +static int cdns_mhdp_mailbox_read_receive(struct cdns_mhdp_device *mhdp,
935 + u8 *buff, u16 buff_size)
936 {
937 u32 i;
938 int ret;
939
940 for (i = 0; i < buff_size; i++) {
941 - ret = cdn_dp_mailbox_read(dp);
942 + ret = cdns_mhdp_mailbox_read(mhdp);
943 if (ret < 0)
944 return ret;
945
946 @@ -155,8 +155,8 @@ static int cdn_dp_mailbox_read_receive(s
947 return 0;
948 }
949
950 -static int cdn_dp_mailbox_send(struct cdn_dp_device *dp, u8 module_id,
951 - u8 opcode, u16 size, u8 *message)
952 +static int cdns_mhdp_mailbox_send(struct cdns_mhdp_device *mhdp, u8 module_id,
953 + u8 opcode, u16 size, u8 *message)
954 {
955 u8 header[4];
956 int ret, i;
957 @@ -167,13 +167,13 @@ static int cdn_dp_mailbox_send(struct cd
958 header[3] = size & 0xff;
959
960 for (i = 0; i < 4; i++) {
961 - ret = cdp_dp_mailbox_write(dp, header[i]);
962 + ret = cdp_dp_mailbox_write(mhdp, header[i]);
963 if (ret)
964 return ret;
965 }
966
967 for (i = 0; i < size; i++) {
968 - ret = cdp_dp_mailbox_write(dp, message[i]);
969 + ret = cdp_dp_mailbox_write(mhdp, message[i]);
970 if (ret)
971 return ret;
972 }
973 @@ -181,7 +181,7 @@ static int cdn_dp_mailbox_send(struct cd
974 return 0;
975 }
976
977 -static int cdn_dp_reg_write(struct cdn_dp_device *dp, u16 addr, u32 val)
978 +static int cdns_mhdp_reg_write(struct cdns_mhdp_device *mhdp, u16 addr, u32 val)
979 {
980 u8 msg[6];
981
982 @@ -191,12 +191,12 @@ static int cdn_dp_reg_write(struct cdn_d
983 msg[3] = (val >> 16) & 0xff;
984 msg[4] = (val >> 8) & 0xff;
985 msg[5] = val & 0xff;
986 - return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_REGISTER,
987 - sizeof(msg), msg);
988 + return cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
989 + DPTX_WRITE_REGISTER, sizeof(msg), msg);
990 }
991
992 -static int cdn_dp_reg_write_bit(struct cdn_dp_device *dp, u16 addr,
993 - u8 start_bit, u8 bits_no, u32 val)
994 +static int cdns_mhdp_reg_write_bit(struct cdns_mhdp_device *mhdp, u16 addr,
995 + u8 start_bit, u8 bits_no, u32 val)
996 {
997 u8 field[8];
998
999 @@ -209,11 +209,12 @@ static int cdn_dp_reg_write_bit(struct c
1000 field[6] = (val >> 8) & 0xff;
1001 field[7] = val & 0xff;
1002
1003 - return cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_FIELD,
1004 - sizeof(field), field);
1005 + return cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
1006 + DPTX_WRITE_FIELD, sizeof(field), field);
1007 }
1008
1009 -int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len)
1010 +int cdns_mhdp_dpcd_read(struct cdns_mhdp_device *mhdp,
1011 + u32 addr, u8 *data, u16 len)
1012 {
1013 u8 msg[5], reg[5];
1014 int ret;
1015 @@ -223,28 +224,28 @@ int cdn_dp_dpcd_read(struct cdn_dp_devic
1016 msg[2] = (addr >> 16) & 0xff;
1017 msg[3] = (addr >> 8) & 0xff;
1018 msg[4] = addr & 0xff;
1019 - ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_DPCD,
1020 - sizeof(msg), msg);
1021 + ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
1022 + DPTX_READ_DPCD, sizeof(msg), msg);
1023 if (ret)
1024 goto err_dpcd_read;
1025
1026 - ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
1027 - DPTX_READ_DPCD,
1028 - sizeof(reg) + len);
1029 + ret = cdns_mhdp_mailbox_validate_receive(mhdp, MB_MODULE_ID_DP_TX,
1030 + DPTX_READ_DPCD,
1031 + sizeof(reg) + len);
1032 if (ret)
1033 goto err_dpcd_read;
1034
1035 - ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg));
1036 + ret = cdns_mhdp_mailbox_read_receive(mhdp, reg, sizeof(reg));
1037 if (ret)
1038 goto err_dpcd_read;
1039
1040 - ret = cdn_dp_mailbox_read_receive(dp, data, len);
1041 + ret = cdns_mhdp_mailbox_read_receive(mhdp, data, len);
1042
1043 err_dpcd_read:
1044 return ret;
1045 }
1046
1047 -int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value)
1048 +int cdns_mhdp_dpcd_write(struct cdns_mhdp_device *mhdp, u32 addr, u8 value)
1049 {
1050 u8 msg[6], reg[5];
1051 int ret;
1052 @@ -255,17 +256,17 @@ int cdn_dp_dpcd_write(struct cdn_dp_devi
1053 msg[3] = (addr >> 8) & 0xff;
1054 msg[4] = addr & 0xff;
1055 msg[5] = value;
1056 - ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_WRITE_DPCD,
1057 - sizeof(msg), msg);
1058 + ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
1059 + DPTX_WRITE_DPCD, sizeof(msg), msg);
1060 if (ret)
1061 goto err_dpcd_write;
1062
1063 - ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
1064 - DPTX_WRITE_DPCD, sizeof(reg));
1065 + ret = cdns_mhdp_mailbox_validate_receive(mhdp, MB_MODULE_ID_DP_TX,
1066 + DPTX_WRITE_DPCD, sizeof(reg));
1067 if (ret)
1068 goto err_dpcd_write;
1069
1070 - ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg));
1071 + ret = cdns_mhdp_mailbox_read_receive(mhdp, reg, sizeof(reg));
1072 if (ret)
1073 goto err_dpcd_write;
1074
1075 @@ -274,53 +275,53 @@ int cdn_dp_dpcd_write(struct cdn_dp_devi
1076
1077 err_dpcd_write:
1078 if (ret)
1079 - DRM_DEV_ERROR(dp->dev, "dpcd write failed: %d\n", ret);
1080 + DRM_DEV_ERROR(mhdp->dev, "dpcd write failed: %d\n", ret);
1081 return ret;
1082 }
1083
1084 -int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem,
1085 - u32 i_size, const u32 *d_mem, u32 d_size)
1086 +int cdns_mhdp_load_firmware(struct cdns_mhdp_device *mhdp, const u32 *i_mem,
1087 + u32 i_size, const u32 *d_mem, u32 d_size)
1088 {
1089 u32 reg;
1090 int i, ret;
1091
1092 /* reset ucpu before load firmware*/
1093 writel(APB_IRAM_PATH | APB_DRAM_PATH | APB_XT_RESET,
1094 - dp->regs + APB_CTRL);
1095 + mhdp->regs + APB_CTRL);
1096
1097 for (i = 0; i < i_size; i += 4)
1098 - writel(*i_mem++, dp->regs + ADDR_IMEM + i);
1099 + writel(*i_mem++, mhdp->regs + ADDR_IMEM + i);
1100
1101 for (i = 0; i < d_size; i += 4)
1102 - writel(*d_mem++, dp->regs + ADDR_DMEM + i);
1103 + writel(*d_mem++, mhdp->regs + ADDR_DMEM + i);
1104
1105 /* un-reset ucpu */
1106 - writel(0, dp->regs + APB_CTRL);
1107 + writel(0, mhdp->regs + APB_CTRL);
1108
1109 /* check the keep alive register to make sure fw working */
1110 - ret = readx_poll_timeout(readl, dp->regs + KEEP_ALIVE,
1111 + ret = readx_poll_timeout(readl, mhdp->regs + KEEP_ALIVE,
1112 reg, reg, 2000, FW_ALIVE_TIMEOUT_US);
1113 if (ret < 0) {
1114 - DRM_DEV_ERROR(dp->dev, "failed to loaded the FW reg = %x\n",
1115 + DRM_DEV_ERROR(mhdp->dev, "failed to loaded the FW reg = %x\n",
1116 reg);
1117 return -EINVAL;
1118 }
1119
1120 - reg = readl(dp->regs + VER_L) & 0xff;
1121 - dp->fw_version = reg;
1122 - reg = readl(dp->regs + VER_H) & 0xff;
1123 - dp->fw_version |= reg << 8;
1124 - reg = readl(dp->regs + VER_LIB_L_ADDR) & 0xff;
1125 - dp->fw_version |= reg << 16;
1126 - reg = readl(dp->regs + VER_LIB_H_ADDR) & 0xff;
1127 - dp->fw_version |= reg << 24;
1128 + reg = readl(mhdp->regs + VER_L) & 0xff;
1129 + mhdp->fw_version = reg;
1130 + reg = readl(mhdp->regs + VER_H) & 0xff;
1131 + mhdp->fw_version |= reg << 8;
1132 + reg = readl(mhdp->regs + VER_LIB_L_ADDR) & 0xff;
1133 + mhdp->fw_version |= reg << 16;
1134 + reg = readl(mhdp->regs + VER_LIB_H_ADDR) & 0xff;
1135 + mhdp->fw_version |= reg << 24;
1136
1137 - DRM_DEV_DEBUG(dp->dev, "firmware version: %x\n", dp->fw_version);
1138 + DRM_DEV_DEBUG(mhdp->dev, "firmware version: %x\n", mhdp->fw_version);
1139
1140 return 0;
1141 }
1142
1143 -int cdn_dp_set_firmware_active(struct cdn_dp_device *dp, bool enable)
1144 +int cdns_mhdp_set_firmware_active(struct cdns_mhdp_device *mhdp, bool enable)
1145 {
1146 u8 msg[5];
1147 int ret, i;
1148 @@ -332,14 +333,14 @@ int cdn_dp_set_firmware_active(struct cd
1149 msg[4] = enable ? FW_ACTIVE : FW_STANDBY;
1150
1151 for (i = 0; i < sizeof(msg); i++) {
1152 - ret = cdp_dp_mailbox_write(dp, msg[i]);
1153 + ret = cdp_dp_mailbox_write(mhdp, msg[i]);
1154 if (ret)
1155 goto err_set_firmware_active;
1156 }
1157
1158 /* read the firmware state */
1159 for (i = 0; i < sizeof(msg); i++) {
1160 - ret = cdn_dp_mailbox_read(dp);
1161 + ret = cdns_mhdp_mailbox_read(mhdp);
1162 if (ret < 0)
1163 goto err_set_firmware_active;
1164
1165 @@ -350,16 +351,16 @@ int cdn_dp_set_firmware_active(struct cd
1166
1167 err_set_firmware_active:
1168 if (ret < 0)
1169 - DRM_DEV_ERROR(dp->dev, "set firmware active failed\n");
1170 + DRM_DEV_ERROR(mhdp->dev, "set firmware active failed\n");
1171 return ret;
1172 }
1173
1174 -int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes, bool flip)
1175 +int cdns_mhdp_set_host_cap(struct cdns_mhdp_device *mhdp, u8 lanes, bool flip)
1176 {
1177 u8 msg[8];
1178 int ret;
1179
1180 - msg[0] = CDN_DP_MAX_LINK_RATE;
1181 + msg[0] = CDNS_DP_MAX_LINK_RATE;
1182 msg[1] = lanes | SCRAMBLER_EN;
1183 msg[2] = VOLTAGE_LEVEL_2;
1184 msg[3] = PRE_EMPHASIS_LEVEL_3;
1185 @@ -368,22 +369,22 @@ int cdn_dp_set_host_cap(struct cdn_dp_de
1186 msg[6] = flip ? LANE_MAPPING_FLIPPED : LANE_MAPPING_NORMAL;
1187 msg[7] = ENHANCED;
1188
1189 - ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX,
1190 - DPTX_SET_HOST_CAPABILITIES,
1191 - sizeof(msg), msg);
1192 + ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
1193 + DPTX_SET_HOST_CAPABILITIES,
1194 + sizeof(msg), msg);
1195 if (ret)
1196 goto err_set_host_cap;
1197
1198 - ret = cdn_dp_reg_write(dp, DP_AUX_SWAP_INVERSION_CONTROL,
1199 - AUX_HOST_INVERT);
1200 + ret = cdns_mhdp_reg_write(mhdp, DP_AUX_SWAP_INVERSION_CONTROL,
1201 + AUX_HOST_INVERT);
1202
1203 err_set_host_cap:
1204 if (ret)
1205 - DRM_DEV_ERROR(dp->dev, "set host cap failed: %d\n", ret);
1206 + DRM_DEV_ERROR(mhdp->dev, "set host cap failed: %d\n", ret);
1207 return ret;
1208 }
1209
1210 -int cdn_dp_event_config(struct cdn_dp_device *dp)
1211 +int cdns_mhdp_event_config(struct cdns_mhdp_device *mhdp)
1212 {
1213 u8 msg[5];
1214 int ret;
1215 @@ -392,49 +393,50 @@ int cdn_dp_event_config(struct cdn_dp_de
1216
1217 msg[0] = DPTX_EVENT_ENABLE_HPD | DPTX_EVENT_ENABLE_TRAINING;
1218
1219 - ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_ENABLE_EVENT,
1220 - sizeof(msg), msg);
1221 + ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
1222 + DPTX_ENABLE_EVENT, sizeof(msg), msg);
1223 if (ret)
1224 - DRM_DEV_ERROR(dp->dev, "set event config failed: %d\n", ret);
1225 + DRM_DEV_ERROR(mhdp->dev, "set event config failed: %d\n", ret);
1226
1227 return ret;
1228 }
1229
1230 -u32 cdn_dp_get_event(struct cdn_dp_device *dp)
1231 +u32 cdns_mhdp_get_event(struct cdns_mhdp_device *mhdp)
1232 {
1233 - return readl(dp->regs + SW_EVENTS0);
1234 + return readl(mhdp->regs + SW_EVENTS0);
1235 }
1236
1237 -int cdn_dp_get_hpd_status(struct cdn_dp_device *dp)
1238 +int cdns_mhdp_get_hpd_status(struct cdns_mhdp_device *mhdp)
1239 {
1240 u8 status;
1241 int ret;
1242
1243 - ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_HPD_STATE,
1244 - 0, NULL);
1245 + ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
1246 + DPTX_HPD_STATE, 0, NULL);
1247 if (ret)
1248 goto err_get_hpd;
1249
1250 - ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
1251 - DPTX_HPD_STATE, sizeof(status));
1252 + ret = cdns_mhdp_mailbox_validate_receive(mhdp, MB_MODULE_ID_DP_TX,
1253 + DPTX_HPD_STATE,
1254 + sizeof(status));
1255 if (ret)
1256 goto err_get_hpd;
1257
1258 - ret = cdn_dp_mailbox_read_receive(dp, &status, sizeof(status));
1259 + ret = cdns_mhdp_mailbox_read_receive(mhdp, &status, sizeof(status));
1260 if (ret)
1261 goto err_get_hpd;
1262
1263 return status;
1264
1265 err_get_hpd:
1266 - DRM_DEV_ERROR(dp->dev, "get hpd status failed: %d\n", ret);
1267 + DRM_DEV_ERROR(mhdp->dev, "get hpd status failed: %d\n", ret);
1268 return ret;
1269 }
1270
1271 -int cdn_dp_get_edid_block(void *data, u8 *edid,
1272 +int cdns_mhdp_get_edid_block(void *data, u8 *edid,
1273 unsigned int block, size_t length)
1274 {
1275 - struct cdn_dp_device *dp = data;
1276 + struct cdns_mhdp_device *mhdp = data;
1277 u8 msg[2], reg[2], i;
1278 int ret;
1279
1280 @@ -442,22 +444,23 @@ int cdn_dp_get_edid_block(void *data, u8
1281 msg[0] = block / 2;
1282 msg[1] = block % 2;
1283
1284 - ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_GET_EDID,
1285 - sizeof(msg), msg);
1286 + ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
1287 + DPTX_GET_EDID, sizeof(msg), msg);
1288 if (ret)
1289 continue;
1290
1291 - ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
1292 - DPTX_GET_EDID,
1293 - sizeof(reg) + length);
1294 + ret = cdns_mhdp_mailbox_validate_receive(mhdp,
1295 + MB_MODULE_ID_DP_TX,
1296 + DPTX_GET_EDID,
1297 + sizeof(reg) + length);
1298 if (ret)
1299 continue;
1300
1301 - ret = cdn_dp_mailbox_read_receive(dp, reg, sizeof(reg));
1302 + ret = cdns_mhdp_mailbox_read_receive(mhdp, reg, sizeof(reg));
1303 if (ret)
1304 continue;
1305
1306 - ret = cdn_dp_mailbox_read_receive(dp, edid, length);
1307 + ret = cdns_mhdp_mailbox_read_receive(mhdp, edid, length);
1308 if (ret)
1309 continue;
1310
1311 @@ -466,13 +469,13 @@ int cdn_dp_get_edid_block(void *data, u8
1312 }
1313
1314 if (ret)
1315 - DRM_DEV_ERROR(dp->dev, "get block[%d] edid failed: %d\n", block,
1316 - ret);
1317 + DRM_DEV_ERROR(mhdp->dev, "get block[%d] edid failed: %d\n",
1318 + block, ret);
1319
1320 return ret;
1321 }
1322
1323 -static int cdn_dp_training_start(struct cdn_dp_device *dp)
1324 +static int cdns_mhdp_training_start(struct cdns_mhdp_device *mhdp)
1325 {
1326 unsigned long timeout;
1327 u8 msg, event[2];
1328 @@ -481,26 +484,28 @@ static int cdn_dp_training_start(struct
1329 msg = LINK_TRAINING_RUN;
1330
1331 /* start training */
1332 - ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_TRAINING_CONTROL,
1333 - sizeof(msg), &msg);
1334 + ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
1335 + DPTX_TRAINING_CONTROL, sizeof(msg), &msg);
1336 if (ret)
1337 goto err_training_start;
1338
1339 timeout = jiffies + msecs_to_jiffies(LINK_TRAINING_TIMEOUT_MS);
1340 while (time_before(jiffies, timeout)) {
1341 msleep(LINK_TRAINING_RETRY_MS);
1342 - ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX,
1343 - DPTX_READ_EVENT, 0, NULL);
1344 + ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX,
1345 + DPTX_READ_EVENT, 0, NULL);
1346 if (ret)
1347 goto err_training_start;
1348
1349 - ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
1350 - DPTX_READ_EVENT,
1351 - sizeof(event));
1352 + ret = cdns_mhdp_mailbox_validate_receive(mhdp,
1353 + MB_MODULE_ID_DP_TX,
1354 + DPTX_READ_EVENT,
1355 + sizeof(event));
1356 if (ret)
1357 goto err_training_start;
1358
1359 - ret = cdn_dp_mailbox_read_receive(dp, event, sizeof(event));
1360 + ret = cdns_mhdp_mailbox_read_receive(mhdp, event,
1361 + sizeof(event));
1362 if (ret)
1363 goto err_training_start;
1364
1365 @@ -511,76 +516,76 @@ static int cdn_dp_training_start(struct
1366 ret = -ETIMEDOUT;
1367
1368 err_training_start:
1369 - DRM_DEV_ERROR(dp->dev, "training failed: %d\n", ret);
1370 + DRM_DEV_ERROR(mhdp->dev, "training failed: %d\n", ret);
1371 return ret;
1372 }
1373
1374 -static int cdn_dp_get_training_status(struct cdn_dp_device *dp)
1375 +static int cdns_mhdp_get_training_status(struct cdns_mhdp_device *mhdp)
1376 {
1377 u8 status[10];
1378 int ret;
1379
1380 - ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_READ_LINK_STAT,
1381 + ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX, DPTX_READ_LINK_STAT,
1382 0, NULL);
1383 if (ret)
1384 goto err_get_training_status;
1385
1386 - ret = cdn_dp_mailbox_validate_receive(dp, MB_MODULE_ID_DP_TX,
1387 + ret = cdns_mhdp_mailbox_validate_receive(mhdp, MB_MODULE_ID_DP_TX,
1388 DPTX_READ_LINK_STAT,
1389 sizeof(status));
1390 if (ret)
1391 goto err_get_training_status;
1392
1393 - ret = cdn_dp_mailbox_read_receive(dp, status, sizeof(status));
1394 + ret = cdns_mhdp_mailbox_read_receive(mhdp, status, sizeof(status));
1395 if (ret)
1396 goto err_get_training_status;
1397
1398 - dp->link.rate = drm_dp_bw_code_to_link_rate(status[0]);
1399 - dp->link.num_lanes = status[1];
1400 + mhdp->link.rate = drm_dp_bw_code_to_link_rate(status[0]);
1401 + mhdp->link.num_lanes = status[1];
1402
1403 err_get_training_status:
1404 if (ret)
1405 - DRM_DEV_ERROR(dp->dev, "get training status failed: %d\n", ret);
1406 + DRM_DEV_ERROR(mhdp->dev, "get training status failed: %d\n", ret);
1407 return ret;
1408 }
1409
1410 -int cdn_dp_train_link(struct cdn_dp_device *dp)
1411 +int cdns_mhdp_train_link(struct cdns_mhdp_device *mhdp)
1412 {
1413 int ret;
1414
1415 - ret = cdn_dp_training_start(dp);
1416 + ret = cdns_mhdp_training_start(mhdp);
1417 if (ret) {
1418 - DRM_DEV_ERROR(dp->dev, "Failed to start training %d\n", ret);
1419 + DRM_DEV_ERROR(mhdp->dev, "Failed to start training %d\n", ret);
1420 return ret;
1421 }
1422
1423 - ret = cdn_dp_get_training_status(dp);
1424 + ret = cdns_mhdp_get_training_status(mhdp);
1425 if (ret) {
1426 - DRM_DEV_ERROR(dp->dev, "Failed to get training stat %d\n", ret);
1427 + DRM_DEV_ERROR(mhdp->dev, "Failed to get training stat %d\n", ret);
1428 return ret;
1429 }
1430
1431 - DRM_DEV_DEBUG_KMS(dp->dev, "rate:0x%x, lanes:%d\n", dp->link.rate,
1432 - dp->link.num_lanes);
1433 + DRM_DEV_DEBUG_KMS(mhdp->dev, "rate:0x%x, lanes:%d\n", mhdp->link.rate,
1434 + mhdp->link.num_lanes);
1435 return ret;
1436 }
1437
1438 -int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active)
1439 +int cdns_mhdp_set_video_status(struct cdns_mhdp_device *mhdp, int active)
1440 {
1441 u8 msg;
1442 int ret;
1443
1444 msg = !!active;
1445
1446 - ret = cdn_dp_mailbox_send(dp, MB_MODULE_ID_DP_TX, DPTX_SET_VIDEO,
1447 + ret = cdns_mhdp_mailbox_send(mhdp, MB_MODULE_ID_DP_TX, DPTX_SET_VIDEO,
1448 sizeof(msg), &msg);
1449 if (ret)
1450 - DRM_DEV_ERROR(dp->dev, "set video status failed: %d\n", ret);
1451 + DRM_DEV_ERROR(mhdp->dev, "set video status failed: %d\n", ret);
1452
1453 return ret;
1454 }
1455
1456 -static int cdn_dp_get_msa_misc(struct video_info *video,
1457 +static int cdns_mhdp_get_msa_misc(struct video_info *video,
1458 struct drm_display_mode *mode)
1459 {
1460 u32 msa_misc;
1461 @@ -627,10 +632,10 @@ static int cdn_dp_get_msa_misc(struct vi
1462 return msa_misc;
1463 }
1464
1465 -int cdn_dp_config_video(struct cdn_dp_device *dp)
1466 +int cdns_mhdp_config_video(struct cdns_mhdp_device *mhdp)
1467 {
1468 - struct video_info *video = &dp->video_info;
1469 - struct drm_display_mode *mode = &dp->mode;
1470 + struct video_info *video = &mhdp->video_info;
1471 + struct drm_display_mode *mode = &mhdp->mode;
1472 u64 symbol;
1473 u32 val, link_rate, rem;
1474 u8 bit_per_pix, tu_size_reg = TU_SIZE;
1475 @@ -639,13 +644,13 @@ int cdn_dp_config_video(struct cdn_dp_de
1476 bit_per_pix = (video->color_fmt == YCBCR_4_2_2) ?
1477 (video->color_depth * 2) : (video->color_depth * 3);
1478
1479 - link_rate = dp->link.rate / 1000;
1480 + link_rate = mhdp->link.rate / 1000;
1481
1482 - ret = cdn_dp_reg_write(dp, BND_HSYNC2VSYNC, VIF_BYPASS_INTERLACE);
1483 + ret = cdns_mhdp_reg_write(mhdp, BND_HSYNC2VSYNC, VIF_BYPASS_INTERLACE);
1484 if (ret)
1485 goto err_config_video;
1486
1487 - ret = cdn_dp_reg_write(dp, HSYNC2VSYNC_POL_CTRL, 0);
1488 + ret = cdns_mhdp_reg_write(mhdp, HSYNC2VSYNC_POL_CTRL, 0);
1489 if (ret)
1490 goto err_config_video;
1491
1492 @@ -659,13 +664,13 @@ int cdn_dp_config_video(struct cdn_dp_de
1493 do {
1494 tu_size_reg += 2;
1495 symbol = tu_size_reg * mode->clock * bit_per_pix;
1496 - do_div(symbol, dp->link.num_lanes * link_rate * 8);
1497 + do_div(symbol, mhdp->link.num_lanes * link_rate * 8);
1498 rem = do_div(symbol, 1000);
1499 if (tu_size_reg > 64) {
1500 ret = -EINVAL;
1501 - DRM_DEV_ERROR(dp->dev,
1502 + DRM_DEV_ERROR(mhdp->dev,
1503 "tu error, clk:%d, lanes:%d, rate:%d\n",
1504 - mode->clock, dp->link.num_lanes,
1505 + mode->clock, mhdp->link.num_lanes,
1506 link_rate);
1507 goto err_config_video;
1508 }
1509 @@ -674,16 +679,16 @@ int cdn_dp_config_video(struct cdn_dp_de
1510
1511 val = symbol + (tu_size_reg << 8);
1512 val |= TU_CNT_RST_EN;
1513 - ret = cdn_dp_reg_write(dp, DP_FRAMER_TU, val);
1514 + ret = cdns_mhdp_reg_write(mhdp, DP_FRAMER_TU, val);
1515 if (ret)
1516 goto err_config_video;
1517
1518 /* set the FIFO Buffer size */
1519 val = div_u64(mode->clock * (symbol + 1), 1000) + link_rate;
1520 - val /= (dp->link.num_lanes * link_rate);
1521 + val /= (mhdp->link.num_lanes * link_rate);
1522 val = div_u64(8 * (symbol + 1), bit_per_pix) - val;
1523 val += 2;
1524 - ret = cdn_dp_reg_write(dp, DP_VC_TABLE(15), val);
1525 + ret = cdns_mhdp_reg_write(mhdp, DP_VC_TABLE(15), val);
1526
1527 switch (video->color_depth) {
1528 case 6:
1529 @@ -704,136 +709,137 @@ int cdn_dp_config_video(struct cdn_dp_de
1530 };
1531
1532 val += video->color_fmt << 8;
1533 - ret = cdn_dp_reg_write(dp, DP_FRAMER_PXL_REPR, val);
1534 + ret = cdns_mhdp_reg_write(mhdp, DP_FRAMER_PXL_REPR, val);
1535 if (ret)
1536 goto err_config_video;
1537
1538 val = video->h_sync_polarity ? DP_FRAMER_SP_HSP : 0;
1539 val |= video->v_sync_polarity ? DP_FRAMER_SP_VSP : 0;
1540 - ret = cdn_dp_reg_write(dp, DP_FRAMER_SP, val);
1541 + ret = cdns_mhdp_reg_write(mhdp, DP_FRAMER_SP, val);
1542 if (ret)
1543 goto err_config_video;
1544
1545 val = (mode->hsync_start - mode->hdisplay) << 16;
1546 val |= mode->htotal - mode->hsync_end;
1547 - ret = cdn_dp_reg_write(dp, DP_FRONT_BACK_PORCH, val);
1548 + ret = cdns_mhdp_reg_write(mhdp, DP_FRONT_BACK_PORCH, val);
1549 if (ret)
1550 goto err_config_video;
1551
1552 val = mode->hdisplay * bit_per_pix / 8;
1553 - ret = cdn_dp_reg_write(dp, DP_BYTE_COUNT, val);
1554 + ret = cdns_mhdp_reg_write(mhdp, DP_BYTE_COUNT, val);
1555 if (ret)
1556 goto err_config_video;
1557
1558 val = mode->htotal | ((mode->htotal - mode->hsync_start) << 16);
1559 - ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_0, val);
1560 + ret = cdns_mhdp_reg_write(mhdp, MSA_HORIZONTAL_0, val);
1561 if (ret)
1562 goto err_config_video;
1563
1564 val = mode->hsync_end - mode->hsync_start;
1565 val |= (mode->hdisplay << 16) | (video->h_sync_polarity << 15);
1566 - ret = cdn_dp_reg_write(dp, MSA_HORIZONTAL_1, val);
1567 + ret = cdns_mhdp_reg_write(mhdp, MSA_HORIZONTAL_1, val);
1568 if (ret)
1569 goto err_config_video;
1570
1571 val = mode->vtotal;
1572 val |= (mode->vtotal - mode->vsync_start) << 16;
1573 - ret = cdn_dp_reg_write(dp, MSA_VERTICAL_0, val);
1574 + ret = cdns_mhdp_reg_write(mhdp, MSA_VERTICAL_0, val);
1575 if (ret)
1576 goto err_config_video;
1577
1578 val = mode->vsync_end - mode->vsync_start;
1579 val |= (mode->vdisplay << 16) | (video->v_sync_polarity << 15);
1580 - ret = cdn_dp_reg_write(dp, MSA_VERTICAL_1, val);
1581 + ret = cdns_mhdp_reg_write(mhdp, MSA_VERTICAL_1, val);
1582 if (ret)
1583 goto err_config_video;
1584
1585 - val = cdn_dp_get_msa_misc(video, mode);
1586 - ret = cdn_dp_reg_write(dp, MSA_MISC, val);
1587 + val = cdns_mhdp_get_msa_misc(video, mode);
1588 + ret = cdns_mhdp_reg_write(mhdp, MSA_MISC, val);
1589 if (ret)
1590 goto err_config_video;
1591
1592 - ret = cdn_dp_reg_write(dp, STREAM_CONFIG, 1);
1593 + ret = cdns_mhdp_reg_write(mhdp, STREAM_CONFIG, 1);
1594 if (ret)
1595 goto err_config_video;
1596
1597 val = mode->hsync_end - mode->hsync_start;
1598 val |= mode->hdisplay << 16;
1599 - ret = cdn_dp_reg_write(dp, DP_HORIZONTAL, val);
1600 + ret = cdns_mhdp_reg_write(mhdp, DP_HORIZONTAL, val);
1601 if (ret)
1602 goto err_config_video;
1603
1604 val = mode->vdisplay;
1605 val |= (mode->vtotal - mode->vsync_start) << 16;
1606 - ret = cdn_dp_reg_write(dp, DP_VERTICAL_0, val);
1607 + ret = cdns_mhdp_reg_write(mhdp, DP_VERTICAL_0, val);
1608 if (ret)
1609 goto err_config_video;
1610
1611 val = mode->vtotal;
1612 - ret = cdn_dp_reg_write(dp, DP_VERTICAL_1, val);
1613 + ret = cdns_mhdp_reg_write(mhdp, DP_VERTICAL_1, val);
1614 if (ret)
1615 goto err_config_video;
1616
1617 - ret = cdn_dp_reg_write_bit(dp, DP_VB_ID, 2, 1, 0);
1618 + ret = cdns_mhdp_reg_write_bit(mhdp, DP_VB_ID, 2, 1, 0);
1619
1620 err_config_video:
1621 if (ret)
1622 - DRM_DEV_ERROR(dp->dev, "config video failed: %d\n", ret);
1623 + DRM_DEV_ERROR(mhdp->dev, "config video failed: %d\n", ret);
1624 return ret;
1625 }
1626
1627 -int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio)
1628 +int cdns_mhdp_audio_stop(struct cdns_mhdp_device *mhdp,
1629 + struct audio_info *audio)
1630 {
1631 int ret;
1632
1633 - ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, 0);
1634 + ret = cdns_mhdp_reg_write(mhdp, AUDIO_PACK_CONTROL, 0);
1635 if (ret) {
1636 - DRM_DEV_ERROR(dp->dev, "audio stop failed: %d\n", ret);
1637 + DRM_DEV_ERROR(mhdp->dev, "audio stop failed: %d\n", ret);
1638 return ret;
1639 }
1640
1641 - writel(0, dp->regs + SPDIF_CTRL_ADDR);
1642 + writel(0, mhdp->regs + SPDIF_CTRL_ADDR);
1643
1644 /* clearn the audio config and reset */
1645 - writel(0, dp->regs + AUDIO_SRC_CNTL);
1646 - writel(0, dp->regs + AUDIO_SRC_CNFG);
1647 - writel(AUDIO_SW_RST, dp->regs + AUDIO_SRC_CNTL);
1648 - writel(0, dp->regs + AUDIO_SRC_CNTL);
1649 + writel(0, mhdp->regs + AUDIO_SRC_CNTL);
1650 + writel(0, mhdp->regs + AUDIO_SRC_CNFG);
1651 + writel(AUDIO_SW_RST, mhdp->regs + AUDIO_SRC_CNTL);
1652 + writel(0, mhdp->regs + AUDIO_SRC_CNTL);
1653
1654 /* reset smpl2pckt component */
1655 - writel(0, dp->regs + SMPL2PKT_CNTL);
1656 - writel(AUDIO_SW_RST, dp->regs + SMPL2PKT_CNTL);
1657 - writel(0, dp->regs + SMPL2PKT_CNTL);
1658 + writel(0, mhdp->regs + SMPL2PKT_CNTL);
1659 + writel(AUDIO_SW_RST, mhdp->regs + SMPL2PKT_CNTL);
1660 + writel(0, mhdp->regs + SMPL2PKT_CNTL);
1661
1662 /* reset FIFO */
1663 - writel(AUDIO_SW_RST, dp->regs + FIFO_CNTL);
1664 - writel(0, dp->regs + FIFO_CNTL);
1665 + writel(AUDIO_SW_RST, mhdp->regs + FIFO_CNTL);
1666 + writel(0, mhdp->regs + FIFO_CNTL);
1667
1668 if (audio->format == AFMT_SPDIF)
1669 - clk_disable_unprepare(dp->spdif_clk);
1670 + clk_disable_unprepare(mhdp->spdif_clk);
1671
1672 return 0;
1673 }
1674
1675 -int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable)
1676 +int cdns_mhdp_audio_mute(struct cdns_mhdp_device *mhdp, bool enable)
1677 {
1678 int ret;
1679
1680 - ret = cdn_dp_reg_write_bit(dp, DP_VB_ID, 4, 1, enable);
1681 + ret = cdns_mhdp_reg_write_bit(mhdp, DP_VB_ID, 4, 1, enable);
1682 if (ret)
1683 - DRM_DEV_ERROR(dp->dev, "audio mute failed: %d\n", ret);
1684 + DRM_DEV_ERROR(mhdp->dev, "audio mute failed: %d\n", ret);
1685
1686 return ret;
1687 }
1688
1689 -static void cdn_dp_audio_config_i2s(struct cdn_dp_device *dp,
1690 - struct audio_info *audio)
1691 +static void cdns_mhdp_audio_config_i2s(struct cdns_mhdp_device *mhdp,
1692 + struct audio_info *audio)
1693 {
1694 int sub_pckt_num = 1, i2s_port_en_val = 0xf, i;
1695 u32 val;
1696
1697 if (audio->channels == 2) {
1698 - if (dp->link.num_lanes == 1)
1699 + if (mhdp->link.num_lanes == 1)
1700 sub_pckt_num = 2;
1701 else
1702 sub_pckt_num = 4;
1703 @@ -843,15 +849,15 @@ static void cdn_dp_audio_config_i2s(stru
1704 i2s_port_en_val = 3;
1705 }
1706
1707 - writel(0x0, dp->regs + SPDIF_CTRL_ADDR);
1708 + writel(0x0, mhdp->regs + SPDIF_CTRL_ADDR);
1709
1710 - writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL);
1711 + writel(SYNC_WR_TO_CH_ZERO, mhdp->regs + FIFO_CNTL);
1712
1713 val = MAX_NUM_CH(audio->channels);
1714 val |= NUM_OF_I2S_PORTS(audio->channels);
1715 val |= AUDIO_TYPE_LPCM;
1716 val |= CFG_SUB_PCKT_NUM(sub_pckt_num);
1717 - writel(val, dp->regs + SMPL2PKT_CNFG);
1718 + writel(val, mhdp->regs + SMPL2PKT_CNFG);
1719
1720 if (audio->sample_width == 16)
1721 val = 0;
1722 @@ -863,7 +869,7 @@ static void cdn_dp_audio_config_i2s(stru
1723 val |= AUDIO_CH_NUM(audio->channels);
1724 val |= I2S_DEC_PORT_EN(i2s_port_en_val);
1725 val |= TRANS_SMPL_WIDTH_32;
1726 - writel(val, dp->regs + AUDIO_SRC_CNFG);
1727 + writel(val, mhdp->regs + AUDIO_SRC_CNFG);
1728
1729 for (i = 0; i < (audio->channels + 1) / 2; i++) {
1730 if (audio->sample_width == 16)
1731 @@ -872,7 +878,7 @@ static void cdn_dp_audio_config_i2s(stru
1732 val = (0x0b << 8) | (0x0b << 20);
1733
1734 val |= ((2 * i) << 4) | ((2 * i + 1) << 16);
1735 - writel(val, dp->regs + STTS_BIT_CH(i));
1736 + writel(val, mhdp->regs + STTS_BIT_CH(i));
1737 }
1738
1739 switch (audio->sample_rate) {
1740 @@ -906,56 +912,57 @@ static void cdn_dp_audio_config_i2s(stru
1741 break;
1742 }
1743 val |= 4;
1744 - writel(val, dp->regs + COM_CH_STTS_BITS);
1745 + writel(val, mhdp->regs + COM_CH_STTS_BITS);
1746
1747 - writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL);
1748 - writel(I2S_DEC_START, dp->regs + AUDIO_SRC_CNTL);
1749 + writel(SMPL2PKT_EN, mhdp->regs + SMPL2PKT_CNTL);
1750 + writel(I2S_DEC_START, mhdp->regs + AUDIO_SRC_CNTL);
1751 }
1752
1753 -static void cdn_dp_audio_config_spdif(struct cdn_dp_device *dp)
1754 +static void cdns_mhdp_audio_config_spdif(struct cdns_mhdp_device *mhdp)
1755 {
1756 u32 val;
1757
1758 - writel(SYNC_WR_TO_CH_ZERO, dp->regs + FIFO_CNTL);
1759 + writel(SYNC_WR_TO_CH_ZERO, mhdp->regs + FIFO_CNTL);
1760
1761 val = MAX_NUM_CH(2) | AUDIO_TYPE_LPCM | CFG_SUB_PCKT_NUM(4);
1762 - writel(val, dp->regs + SMPL2PKT_CNFG);
1763 - writel(SMPL2PKT_EN, dp->regs + SMPL2PKT_CNTL);
1764 + writel(val, mhdp->regs + SMPL2PKT_CNFG);
1765 + writel(SMPL2PKT_EN, mhdp->regs + SMPL2PKT_CNTL);
1766
1767 val = SPDIF_ENABLE | SPDIF_AVG_SEL | SPDIF_JITTER_BYPASS;
1768 - writel(val, dp->regs + SPDIF_CTRL_ADDR);
1769 + writel(val, mhdp->regs + SPDIF_CTRL_ADDR);
1770
1771 - clk_prepare_enable(dp->spdif_clk);
1772 - clk_set_rate(dp->spdif_clk, CDN_DP_SPDIF_CLK);
1773 + clk_prepare_enable(mhdp->spdif_clk);
1774 + clk_set_rate(mhdp->spdif_clk, CDNS_DP_SPDIF_CLK);
1775 }
1776
1777 -int cdn_dp_audio_config(struct cdn_dp_device *dp, struct audio_info *audio)
1778 +int cdns_mhdp_audio_config(struct cdns_mhdp_device *mhdp,
1779 + struct audio_info *audio)
1780 {
1781 int ret;
1782
1783 /* reset the spdif clk before config */
1784 if (audio->format == AFMT_SPDIF) {
1785 - reset_control_assert(dp->spdif_rst);
1786 - reset_control_deassert(dp->spdif_rst);
1787 + reset_control_assert(mhdp->spdif_rst);
1788 + reset_control_deassert(mhdp->spdif_rst);
1789 }
1790
1791 - ret = cdn_dp_reg_write(dp, CM_LANE_CTRL, LANE_REF_CYC);
1792 + ret = cdns_mhdp_reg_write(mhdp, CM_LANE_CTRL, LANE_REF_CYC);
1793 if (ret)
1794 goto err_audio_config;
1795
1796 - ret = cdn_dp_reg_write(dp, CM_CTRL, 0);
1797 + ret = cdns_mhdp_reg_write(mhdp, CM_CTRL, 0);
1798 if (ret)
1799 goto err_audio_config;
1800
1801 if (audio->format == AFMT_I2S)
1802 - cdn_dp_audio_config_i2s(dp, audio);
1803 + cdns_mhdp_audio_config_i2s(mhdp, audio);
1804 else if (audio->format == AFMT_SPDIF)
1805 - cdn_dp_audio_config_spdif(dp);
1806 + cdns_mhdp_audio_config_spdif(mhdp);
1807
1808 - ret = cdn_dp_reg_write(dp, AUDIO_PACK_CONTROL, AUDIO_PACK_EN);
1809 + ret = cdns_mhdp_reg_write(mhdp, AUDIO_PACK_CONTROL, AUDIO_PACK_EN);
1810
1811 err_audio_config:
1812 if (ret)
1813 - DRM_DEV_ERROR(dp->dev, "audio config failed: %d\n", ret);
1814 + DRM_DEV_ERROR(mhdp->dev, "audio config failed: %d\n", ret);
1815 return ret;
1816 }
1817 --- a/drivers/gpu/drm/rockchip/cdn-dp-reg.h
1818 +++ b/drivers/gpu/drm/rockchip/cdn-dp-reg.h
1819 @@ -387,7 +387,7 @@
1820 #define HDCP_TX_IS_RECEIVER_ID_VALID_EVENT BIT(7)
1821
1822 #define TU_SIZE 30
1823 -#define CDN_DP_MAX_LINK_RATE DP_LINK_BW_5_4
1824 +#define CDNS_DP_MAX_LINK_RATE DP_LINK_BW_5_4
1825
1826 /* audio */
1827 #define AUDIO_PACK_EN BIT(8)
1828 @@ -451,24 +451,96 @@ enum vic_bt_type {
1829 BT_709 = 0x1,
1830 };
1831
1832 -void cdn_dp_clock_reset(struct cdn_dp_device *dp);
1833 +enum audio_format {
1834 + AFMT_I2S = 0,
1835 + AFMT_SPDIF = 1,
1836 + AFMT_UNUSED,
1837 +};
1838 +
1839 +struct audio_info {
1840 + enum audio_format format;
1841 + int sample_rate;
1842 + int channels;
1843 + int sample_width;
1844 +};
1845 +
1846 +enum vic_pxl_encoding_format {
1847 + PXL_RGB = 0x1,
1848 + YCBCR_4_4_4 = 0x2,
1849 + YCBCR_4_2_2 = 0x4,
1850 + YCBCR_4_2_0 = 0x8,
1851 + Y_ONLY = 0x10,
1852 +};
1853 +
1854 +struct video_info {
1855 + bool h_sync_polarity;
1856 + bool v_sync_polarity;
1857 + bool interlaced;
1858 + int color_depth;
1859 + enum vic_pxl_encoding_format color_fmt;
1860 +};
1861 +
1862 +struct cdns_mhdp_host {
1863 + unsigned int link_rate;
1864 + u8 lanes_cnt;
1865 + u8 volt_swing;
1866 + u8 pre_emphasis;
1867 + u8 pattern_supp;
1868 + u8 fast_link;
1869 + u8 lane_mapping;
1870 + u8 enhanced;
1871 +};
1872 +
1873 +struct cdns_mhdp_sink {
1874 + unsigned int link_rate;
1875 + u8 lanes_cnt;
1876 + u8 pattern_supp;
1877 + u8 fast_link;
1878 + u8 enhanced;
1879 +};
1880 +
1881 +struct cdns_mhdp_device {
1882 + void __iomem *regs;
1883 +
1884 + struct device *dev;
1885 +
1886 + struct drm_dp_link link;
1887 + struct drm_connector connector;
1888 + struct clk *spdif_clk;
1889 + struct reset_control *spdif_rst;
1890 +
1891 + struct drm_dp_aux aux;
1892 + struct cdns_mhdp_host host;
1893 + struct cdns_mhdp_sink sink;
1894 + struct drm_bridge bridge;
1895 + struct phy *phy;
1896 + void __iomem *dbg_regs;
1897 +
1898 + struct video_info video_info;
1899 + struct drm_display_mode mode;
1900 + unsigned int fw_version;
1901 +};
1902
1903 -void cdn_dp_set_fw_clk(struct cdn_dp_device *dp, unsigned long clk);
1904 -int cdn_dp_load_firmware(struct cdn_dp_device *dp, const u32 *i_mem,
1905 - u32 i_size, const u32 *d_mem, u32 d_size);
1906 -int cdn_dp_set_firmware_active(struct cdn_dp_device *dp, bool enable);
1907 -int cdn_dp_set_host_cap(struct cdn_dp_device *dp, u8 lanes, bool flip);
1908 -int cdn_dp_event_config(struct cdn_dp_device *dp);
1909 -u32 cdn_dp_get_event(struct cdn_dp_device *dp);
1910 -int cdn_dp_get_hpd_status(struct cdn_dp_device *dp);
1911 -int cdn_dp_dpcd_write(struct cdn_dp_device *dp, u32 addr, u8 value);
1912 -int cdn_dp_dpcd_read(struct cdn_dp_device *dp, u32 addr, u8 *data, u16 len);
1913 -int cdn_dp_get_edid_block(void *dp, u8 *edid,
1914 - unsigned int block, size_t length);
1915 -int cdn_dp_train_link(struct cdn_dp_device *dp);
1916 -int cdn_dp_set_video_status(struct cdn_dp_device *dp, int active);
1917 -int cdn_dp_config_video(struct cdn_dp_device *dp);
1918 -int cdn_dp_audio_stop(struct cdn_dp_device *dp, struct audio_info *audio);
1919 -int cdn_dp_audio_mute(struct cdn_dp_device *dp, bool enable);
1920 -int cdn_dp_audio_config(struct cdn_dp_device *dp, struct audio_info *audio);
1921 +void cdns_mhdp_clock_reset(struct cdns_mhdp_device *mhdp);
1922 +void cdns_mhdp_set_fw_clk(struct cdns_mhdp_device *mhdp, unsigned long clk);
1923 +int cdns_mhdp_load_firmware(struct cdns_mhdp_device *mhdp, const u32 *i_mem,
1924 + u32 i_size, const u32 *d_mem, u32 d_size);
1925 +int cdns_mhdp_set_firmware_active(struct cdns_mhdp_device *mhdp, bool enable);
1926 +int cdns_mhdp_set_host_cap(struct cdns_mhdp_device *mhdp, u8 lanes, bool flip);
1927 +int cdns_mhdp_event_config(struct cdns_mhdp_device *mhdp);
1928 +u32 cdns_mhdp_get_event(struct cdns_mhdp_device *mhdp);
1929 +int cdns_mhdp_get_hpd_status(struct cdns_mhdp_device *mhdp);
1930 +int cdns_mhdp_dpcd_write(struct cdns_mhdp_device *mhdp, u32 addr, u8 value);
1931 +int cdns_mhdp_dpcd_read(struct cdns_mhdp_device *mhdp,
1932 + u32 addr, u8 *data, u16 len);
1933 +int cdns_mhdp_get_edid_block(void *mhdp, u8 *edid,
1934 + unsigned int block, size_t length);
1935 +int cdns_mhdp_train_link(struct cdns_mhdp_device *mhdp);
1936 +int cdns_mhdp_set_video_status(struct cdns_mhdp_device *mhdp, int active);
1937 +int cdns_mhdp_config_video(struct cdns_mhdp_device *mhdp);
1938 +int cdns_mhdp_audio_stop(struct cdns_mhdp_device *mhdp,
1939 + struct audio_info *audio);
1940 +int cdns_mhdp_audio_mute(struct cdns_mhdp_device *mhdp, bool enable);
1941 +int cdns_mhdp_audio_config(struct cdns_mhdp_device *mhdp,
1942 + struct audio_info *audio);
1943 #endif /* _CDN_DP_REG_H */
OpenWrt Source Repository