1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd
4  * Author:
5  *      Mark Yao <mark.yao@rock-chips.com>
6  *      Sandy Huang <hjc@rock-chips.com>
7  */
8 
9 #include <linux/clk.h>
10 #include <linux/component.h>
11 #include <linux/mfd/syscon.h>
12 #include <linux/of_graph.h>
13 #include <linux/phy/phy.h>
14 #include <linux/pinctrl/devinfo.h>
15 #include <linux/platform_device.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/regmap.h>
18 #include <linux/reset.h>
19 
20 #include <drm/drm_atomic_helper.h>
21 #include <drm/drm_bridge.h>
22 #include <drm/drm_dp_helper.h>
23 #include <drm/drm_of.h>
24 #include <drm/drm_panel.h>
25 #include <drm/drm_probe_helper.h>
26 #include <drm/drm_simple_kms_helper.h>
27 
28 #include "rockchip_drm_drv.h"
29 #include "rockchip_drm_vop.h"
30 #include "rockchip_lvds.h"
31 
32 #define DISPLAY_OUTPUT_RGB		0
33 #define DISPLAY_OUTPUT_LVDS		1
34 #define DISPLAY_OUTPUT_DUAL_LVDS	2
35 
36 struct rockchip_lvds;
37 
38 #define connector_to_lvds(c) \
39 		container_of(c, struct rockchip_lvds, connector)
40 
41 #define encoder_to_lvds(c) \
42 		container_of(c, struct rockchip_lvds, encoder)
43 
44 /**
45  * struct rockchip_lvds_soc_data - rockchip lvds Soc private data
46  * @probe: LVDS platform probe function
47  * @helper_funcs: LVDS connector helper functions
48  */
49 struct rockchip_lvds_soc_data {
50 	int (*probe)(struct platform_device *pdev, struct rockchip_lvds *lvds);
51 	const struct drm_encoder_helper_funcs *helper_funcs;
52 };
53 
54 struct rockchip_lvds {
55 	struct device *dev;
56 	void __iomem *regs;
57 	struct regmap *grf;
58 	struct clk *pclk;
59 	struct phy *dphy;
60 	const struct rockchip_lvds_soc_data *soc_data;
61 	int output; /* rgb lvds or dual lvds output */
62 	int format; /* vesa or jeida format */
63 	struct drm_device *drm_dev;
64 	struct drm_panel *panel;
65 	struct drm_bridge *bridge;
66 	struct drm_connector connector;
67 	struct drm_encoder encoder;
68 	struct dev_pin_info *pins;
69 };
70 
71 static inline void rk3288_writel(struct rockchip_lvds *lvds, u32 offset,
72 				 u32 val)
73 {
74 	writel_relaxed(val, lvds->regs + offset);
75 	if (lvds->output == DISPLAY_OUTPUT_LVDS)
76 		return;
77 	writel_relaxed(val, lvds->regs + offset + RK3288_LVDS_CH1_OFFSET);
78 }
79 
80 static inline int rockchip_lvds_name_to_format(const char *s)
81 {
82 	if (strncmp(s, "jeida-18", 8) == 0)
83 		return LVDS_JEIDA_18;
84 	else if (strncmp(s, "jeida-24", 8) == 0)
85 		return LVDS_JEIDA_24;
86 	else if (strncmp(s, "vesa-24", 7) == 0)
87 		return LVDS_VESA_24;
88 
89 	return -EINVAL;
90 }
91 
92 static inline int rockchip_lvds_name_to_output(const char *s)
93 {
94 	if (strncmp(s, "rgb", 3) == 0)
95 		return DISPLAY_OUTPUT_RGB;
96 	else if (strncmp(s, "lvds", 4) == 0)
97 		return DISPLAY_OUTPUT_LVDS;
98 	else if (strncmp(s, "duallvds", 8) == 0)
99 		return DISPLAY_OUTPUT_DUAL_LVDS;
100 
101 	return -EINVAL;
102 }
103 
104 static const struct drm_connector_funcs rockchip_lvds_connector_funcs = {
105 	.fill_modes = drm_helper_probe_single_connector_modes,
106 	.destroy = drm_connector_cleanup,
107 	.reset = drm_atomic_helper_connector_reset,
108 	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
109 	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
110 };
111 
112 static int rockchip_lvds_connector_get_modes(struct drm_connector *connector)
113 {
114 	struct rockchip_lvds *lvds = connector_to_lvds(connector);
115 	struct drm_panel *panel = lvds->panel;
116 
117 	return drm_panel_get_modes(panel, connector);
118 }
119 
120 static const
121 struct drm_connector_helper_funcs rockchip_lvds_connector_helper_funcs = {
122 	.get_modes = rockchip_lvds_connector_get_modes,
123 };
124 
125 static int
126 rockchip_lvds_encoder_atomic_check(struct drm_encoder *encoder,
127 				   struct drm_crtc_state *crtc_state,
128 				   struct drm_connector_state *conn_state)
129 {
130 	struct rockchip_crtc_state *s = to_rockchip_crtc_state(crtc_state);
131 
132 	s->output_mode = ROCKCHIP_OUT_MODE_P888;
133 	s->output_type = DRM_MODE_CONNECTOR_LVDS;
134 
135 	return 0;
136 }
137 
138 static int rk3288_lvds_poweron(struct rockchip_lvds *lvds)
139 {
140 	int ret;
141 	u32 val;
142 
143 	ret = clk_enable(lvds->pclk);
144 	if (ret < 0) {
145 		DRM_DEV_ERROR(lvds->dev, "failed to enable lvds pclk %d\n", ret);
146 		return ret;
147 	}
148 	ret = pm_runtime_get_sync(lvds->dev);
149 	if (ret < 0) {
150 		DRM_DEV_ERROR(lvds->dev, "failed to get pm runtime: %d\n", ret);
151 		clk_disable(lvds->pclk);
152 		return ret;
153 	}
154 	val = RK3288_LVDS_CH0_REG0_LANE4_EN | RK3288_LVDS_CH0_REG0_LANE3_EN |
155 		RK3288_LVDS_CH0_REG0_LANE2_EN | RK3288_LVDS_CH0_REG0_LANE1_EN |
156 		RK3288_LVDS_CH0_REG0_LANE0_EN;
157 	if (lvds->output == DISPLAY_OUTPUT_RGB) {
158 		val |= RK3288_LVDS_CH0_REG0_TTL_EN |
159 			RK3288_LVDS_CH0_REG0_LANECK_EN;
160 		rk3288_writel(lvds, RK3288_LVDS_CH0_REG0, val);
161 		rk3288_writel(lvds, RK3288_LVDS_CH0_REG2,
162 			      RK3288_LVDS_PLL_FBDIV_REG2(0x46));
163 		rk3288_writel(lvds, RK3288_LVDS_CH0_REG4,
164 			      RK3288_LVDS_CH0_REG4_LANECK_TTL_MODE |
165 			      RK3288_LVDS_CH0_REG4_LANE4_TTL_MODE |
166 			      RK3288_LVDS_CH0_REG4_LANE3_TTL_MODE |
167 			      RK3288_LVDS_CH0_REG4_LANE2_TTL_MODE |
168 			      RK3288_LVDS_CH0_REG4_LANE1_TTL_MODE |
169 			      RK3288_LVDS_CH0_REG4_LANE0_TTL_MODE);
170 		rk3288_writel(lvds, RK3288_LVDS_CH0_REG5,
171 			      RK3288_LVDS_CH0_REG5_LANECK_TTL_DATA |
172 			      RK3288_LVDS_CH0_REG5_LANE4_TTL_DATA |
173 			      RK3288_LVDS_CH0_REG5_LANE3_TTL_DATA |
174 			      RK3288_LVDS_CH0_REG5_LANE2_TTL_DATA |
175 			      RK3288_LVDS_CH0_REG5_LANE1_TTL_DATA |
176 			      RK3288_LVDS_CH0_REG5_LANE0_TTL_DATA);
177 	} else {
178 		val |= RK3288_LVDS_CH0_REG0_LVDS_EN |
179 			    RK3288_LVDS_CH0_REG0_LANECK_EN;
180 		rk3288_writel(lvds, RK3288_LVDS_CH0_REG0, val);
181 		rk3288_writel(lvds, RK3288_LVDS_CH0_REG1,
182 			      RK3288_LVDS_CH0_REG1_LANECK_BIAS |
183 			      RK3288_LVDS_CH0_REG1_LANE4_BIAS |
184 			      RK3288_LVDS_CH0_REG1_LANE3_BIAS |
185 			      RK3288_LVDS_CH0_REG1_LANE2_BIAS |
186 			      RK3288_LVDS_CH0_REG1_LANE1_BIAS |
187 			      RK3288_LVDS_CH0_REG1_LANE0_BIAS);
188 		rk3288_writel(lvds, RK3288_LVDS_CH0_REG2,
189 			      RK3288_LVDS_CH0_REG2_RESERVE_ON |
190 			      RK3288_LVDS_CH0_REG2_LANECK_LVDS_MODE |
191 			      RK3288_LVDS_CH0_REG2_LANE4_LVDS_MODE |
192 			      RK3288_LVDS_CH0_REG2_LANE3_LVDS_MODE |
193 			      RK3288_LVDS_CH0_REG2_LANE2_LVDS_MODE |
194 			      RK3288_LVDS_CH0_REG2_LANE1_LVDS_MODE |
195 			      RK3288_LVDS_CH0_REG2_LANE0_LVDS_MODE |
196 			      RK3288_LVDS_PLL_FBDIV_REG2(0x46));
197 		rk3288_writel(lvds, RK3288_LVDS_CH0_REG4, 0x00);
198 		rk3288_writel(lvds, RK3288_LVDS_CH0_REG5, 0x00);
199 	}
200 	rk3288_writel(lvds, RK3288_LVDS_CH0_REG3,
201 		      RK3288_LVDS_PLL_FBDIV_REG3(0x46));
202 	rk3288_writel(lvds, RK3288_LVDS_CH0_REGD,
203 		      RK3288_LVDS_PLL_PREDIV_REGD(0x0a));
204 	rk3288_writel(lvds, RK3288_LVDS_CH0_REG20,
205 		      RK3288_LVDS_CH0_REG20_LSB);
206 
207 	rk3288_writel(lvds, RK3288_LVDS_CFG_REGC,
208 		      RK3288_LVDS_CFG_REGC_PLL_ENABLE);
209 	rk3288_writel(lvds, RK3288_LVDS_CFG_REG21,
210 		      RK3288_LVDS_CFG_REG21_TX_ENABLE);
211 
212 	return 0;
213 }
214 
215 static void rk3288_lvds_poweroff(struct rockchip_lvds *lvds)
216 {
217 	int ret;
218 	u32 val;
219 
220 	rk3288_writel(lvds, RK3288_LVDS_CFG_REG21,
221 		      RK3288_LVDS_CFG_REG21_TX_ENABLE);
222 	rk3288_writel(lvds, RK3288_LVDS_CFG_REGC,
223 		      RK3288_LVDS_CFG_REGC_PLL_ENABLE);
224 	val = LVDS_DUAL | LVDS_TTL_EN | LVDS_CH0_EN | LVDS_CH1_EN | LVDS_PWRDN;
225 	val |= val << 16;
226 	ret = regmap_write(lvds->grf, RK3288_LVDS_GRF_SOC_CON7, val);
227 	if (ret != 0)
228 		DRM_DEV_ERROR(lvds->dev, "Could not write to GRF: %d\n", ret);
229 
230 	pm_runtime_put(lvds->dev);
231 	clk_disable(lvds->pclk);
232 }
233 
234 static int rk3288_lvds_grf_config(struct drm_encoder *encoder,
235 				  struct drm_display_mode *mode)
236 {
237 	struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
238 	u8 pin_hsync = (mode->flags & DRM_MODE_FLAG_PHSYNC) ? 1 : 0;
239 	u8 pin_dclk = (mode->flags & DRM_MODE_FLAG_PCSYNC) ? 1 : 0;
240 	u32 val;
241 	int ret;
242 
243 	/* iomux to LCD data/sync mode */
244 	if (lvds->output == DISPLAY_OUTPUT_RGB)
245 		if (lvds->pins && !IS_ERR(lvds->pins->default_state))
246 			pinctrl_select_state(lvds->pins->p,
247 					     lvds->pins->default_state);
248 	val = lvds->format | LVDS_CH0_EN;
249 	if (lvds->output == DISPLAY_OUTPUT_RGB)
250 		val |= LVDS_TTL_EN | LVDS_CH1_EN;
251 	else if (lvds->output == DISPLAY_OUTPUT_DUAL_LVDS)
252 		val |= LVDS_DUAL | LVDS_CH1_EN;
253 
254 	if ((mode->htotal - mode->hsync_start) & 0x01)
255 		val |= LVDS_START_PHASE_RST_1;
256 
257 	val |= (pin_dclk << 8) | (pin_hsync << 9);
258 	val |= (0xffff << 16);
259 	ret = regmap_write(lvds->grf, RK3288_LVDS_GRF_SOC_CON7, val);
260 	if (ret)
261 		DRM_DEV_ERROR(lvds->dev, "Could not write to GRF: %d\n", ret);
262 
263 	return ret;
264 }
265 
266 static int rk3288_lvds_set_vop_source(struct rockchip_lvds *lvds,
267 				      struct drm_encoder *encoder)
268 {
269 	u32 val;
270 	int ret;
271 
272 	ret = drm_of_encoder_active_endpoint_id(lvds->dev->of_node, encoder);
273 	if (ret < 0)
274 		return ret;
275 
276 	val = RK3288_LVDS_SOC_CON6_SEL_VOP_LIT << 16;
277 	if (ret)
278 		val |= RK3288_LVDS_SOC_CON6_SEL_VOP_LIT;
279 
280 	ret = regmap_write(lvds->grf, RK3288_LVDS_GRF_SOC_CON6, val);
281 	if (ret < 0)
282 		return ret;
283 
284 	return 0;
285 }
286 
287 static void rk3288_lvds_encoder_enable(struct drm_encoder *encoder)
288 {
289 	struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
290 	struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;
291 	int ret;
292 
293 	drm_panel_prepare(lvds->panel);
294 
295 	ret = rk3288_lvds_poweron(lvds);
296 	if (ret < 0) {
297 		DRM_DEV_ERROR(lvds->dev, "failed to power on LVDS: %d\n", ret);
298 		drm_panel_unprepare(lvds->panel);
299 		return;
300 	}
301 
302 	ret = rk3288_lvds_grf_config(encoder, mode);
303 	if (ret) {
304 		DRM_DEV_ERROR(lvds->dev, "failed to configure LVDS: %d\n", ret);
305 		drm_panel_unprepare(lvds->panel);
306 		return;
307 	}
308 
309 	ret = rk3288_lvds_set_vop_source(lvds, encoder);
310 	if (ret) {
311 		DRM_DEV_ERROR(lvds->dev, "failed to set VOP source: %d\n", ret);
312 		drm_panel_unprepare(lvds->panel);
313 		return;
314 	}
315 
316 	drm_panel_enable(lvds->panel);
317 }
318 
319 static void rk3288_lvds_encoder_disable(struct drm_encoder *encoder)
320 {
321 	struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
322 
323 	drm_panel_disable(lvds->panel);
324 	rk3288_lvds_poweroff(lvds);
325 	drm_panel_unprepare(lvds->panel);
326 }
327 
328 static int px30_lvds_poweron(struct rockchip_lvds *lvds)
329 {
330 	int ret;
331 
332 	ret = pm_runtime_get_sync(lvds->dev);
333 	if (ret < 0) {
334 		DRM_DEV_ERROR(lvds->dev, "failed to get pm runtime: %d\n", ret);
335 		return ret;
336 	}
337 
338 	/* Enable LVDS mode */
339 	return regmap_update_bits(lvds->grf, PX30_LVDS_GRF_PD_VO_CON1,
340 				  PX30_LVDS_MODE_EN(1) | PX30_LVDS_P2S_EN(1),
341 				  PX30_LVDS_MODE_EN(1) | PX30_LVDS_P2S_EN(1));
342 }
343 
344 static void px30_lvds_poweroff(struct rockchip_lvds *lvds)
345 {
346 	regmap_update_bits(lvds->grf, PX30_LVDS_GRF_PD_VO_CON1,
347 			   PX30_LVDS_MODE_EN(1) | PX30_LVDS_P2S_EN(1),
348 			   PX30_LVDS_MODE_EN(0) | PX30_LVDS_P2S_EN(0));
349 
350 	pm_runtime_put(lvds->dev);
351 }
352 
353 static int px30_lvds_grf_config(struct drm_encoder *encoder,
354 				struct drm_display_mode *mode)
355 {
356 	struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
357 
358 	if (lvds->output != DISPLAY_OUTPUT_LVDS) {
359 		DRM_DEV_ERROR(lvds->dev, "Unsupported display output %d\n",
360 			      lvds->output);
361 		return -EINVAL;
362 	}
363 
364 	/* Set format */
365 	return regmap_update_bits(lvds->grf, PX30_LVDS_GRF_PD_VO_CON1,
366 				  PX30_LVDS_FORMAT(lvds->format),
367 				  PX30_LVDS_FORMAT(lvds->format));
368 }
369 
370 static int px30_lvds_set_vop_source(struct rockchip_lvds *lvds,
371 				    struct drm_encoder *encoder)
372 {
373 	int vop;
374 
375 	vop = drm_of_encoder_active_endpoint_id(lvds->dev->of_node, encoder);
376 	if (vop < 0)
377 		return vop;
378 
379 	return regmap_update_bits(lvds->grf, PX30_LVDS_GRF_PD_VO_CON1,
380 				  PX30_LVDS_VOP_SEL(1),
381 				  PX30_LVDS_VOP_SEL(vop));
382 }
383 
384 static void px30_lvds_encoder_enable(struct drm_encoder *encoder)
385 {
386 	struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
387 	struct drm_display_mode *mode = &encoder->crtc->state->adjusted_mode;
388 	int ret;
389 
390 	drm_panel_prepare(lvds->panel);
391 
392 	ret = px30_lvds_poweron(lvds);
393 	if (ret) {
394 		DRM_DEV_ERROR(lvds->dev, "failed to power on LVDS: %d\n", ret);
395 		drm_panel_unprepare(lvds->panel);
396 		return;
397 	}
398 
399 	ret = px30_lvds_grf_config(encoder, mode);
400 	if (ret) {
401 		DRM_DEV_ERROR(lvds->dev, "failed to configure LVDS: %d\n", ret);
402 		drm_panel_unprepare(lvds->panel);
403 		return;
404 	}
405 
406 	ret = px30_lvds_set_vop_source(lvds, encoder);
407 	if (ret) {
408 		DRM_DEV_ERROR(lvds->dev, "failed to set VOP source: %d\n", ret);
409 		drm_panel_unprepare(lvds->panel);
410 		return;
411 	}
412 
413 	drm_panel_enable(lvds->panel);
414 }
415 
416 static void px30_lvds_encoder_disable(struct drm_encoder *encoder)
417 {
418 	struct rockchip_lvds *lvds = encoder_to_lvds(encoder);
419 
420 	drm_panel_disable(lvds->panel);
421 	px30_lvds_poweroff(lvds);
422 	drm_panel_unprepare(lvds->panel);
423 }
424 
425 static const
426 struct drm_encoder_helper_funcs rk3288_lvds_encoder_helper_funcs = {
427 	.enable = rk3288_lvds_encoder_enable,
428 	.disable = rk3288_lvds_encoder_disable,
429 	.atomic_check = rockchip_lvds_encoder_atomic_check,
430 };
431 
432 static const
433 struct drm_encoder_helper_funcs px30_lvds_encoder_helper_funcs = {
434 	.enable = px30_lvds_encoder_enable,
435 	.disable = px30_lvds_encoder_disable,
436 	.atomic_check = rockchip_lvds_encoder_atomic_check,
437 };
438 
439 static int rk3288_lvds_probe(struct platform_device *pdev,
440 			     struct rockchip_lvds *lvds)
441 {
442 	struct resource *res;
443 	int ret;
444 
445 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
446 	lvds->regs = devm_ioremap_resource(lvds->dev, res);
447 	if (IS_ERR(lvds->regs))
448 		return PTR_ERR(lvds->regs);
449 
450 	lvds->pclk = devm_clk_get(lvds->dev, "pclk_lvds");
451 	if (IS_ERR(lvds->pclk)) {
452 		DRM_DEV_ERROR(lvds->dev, "could not get pclk_lvds\n");
453 		return PTR_ERR(lvds->pclk);
454 	}
455 
456 	lvds->pins = devm_kzalloc(lvds->dev, sizeof(*lvds->pins),
457 				  GFP_KERNEL);
458 	if (!lvds->pins)
459 		return -ENOMEM;
460 
461 	lvds->pins->p = devm_pinctrl_get(lvds->dev);
462 	if (IS_ERR(lvds->pins->p)) {
463 		DRM_DEV_ERROR(lvds->dev, "no pinctrl handle\n");
464 		devm_kfree(lvds->dev, lvds->pins);
465 		lvds->pins = NULL;
466 	} else {
467 		lvds->pins->default_state =
468 			pinctrl_lookup_state(lvds->pins->p, "lcdc");
469 		if (IS_ERR(lvds->pins->default_state)) {
470 			DRM_DEV_ERROR(lvds->dev, "no default pinctrl state\n");
471 			devm_kfree(lvds->dev, lvds->pins);
472 			lvds->pins = NULL;
473 		}
474 	}
475 
476 	ret = clk_prepare(lvds->pclk);
477 	if (ret < 0) {
478 		DRM_DEV_ERROR(lvds->dev, "failed to prepare pclk_lvds\n");
479 		return ret;
480 	}
481 
482 	return 0;
483 }
484 
485 static int px30_lvds_probe(struct platform_device *pdev,
486 			   struct rockchip_lvds *lvds)
487 {
488 	int ret;
489 
490 	/* MSB */
491 	ret =  regmap_update_bits(lvds->grf, PX30_LVDS_GRF_PD_VO_CON1,
492 				  PX30_LVDS_MSBSEL(1),
493 				  PX30_LVDS_MSBSEL(1));
494 	if (ret)
495 		return ret;
496 
497 	/* PHY */
498 	lvds->dphy = devm_phy_get(&pdev->dev, "dphy");
499 	if (IS_ERR(lvds->dphy))
500 		return PTR_ERR(lvds->dphy);
501 
502 	phy_init(lvds->dphy);
503 	if (ret)
504 		return ret;
505 
506 	phy_set_mode(lvds->dphy, PHY_MODE_LVDS);
507 	if (ret)
508 		return ret;
509 
510 	return phy_power_on(lvds->dphy);
511 }
512 
513 static const struct rockchip_lvds_soc_data rk3288_lvds_data = {
514 	.probe = rk3288_lvds_probe,
515 	.helper_funcs = &rk3288_lvds_encoder_helper_funcs,
516 };
517 
518 static const struct rockchip_lvds_soc_data px30_lvds_data = {
519 	.probe = px30_lvds_probe,
520 	.helper_funcs = &px30_lvds_encoder_helper_funcs,
521 };
522 
523 static const struct of_device_id rockchip_lvds_dt_ids[] = {
524 	{
525 		.compatible = "rockchip,rk3288-lvds",
526 		.data = &rk3288_lvds_data
527 	},
528 	{
529 		.compatible = "rockchip,px30-lvds",
530 		.data = &px30_lvds_data
531 	},
532 	{}
533 };
534 MODULE_DEVICE_TABLE(of, rockchip_lvds_dt_ids);
535 
536 static int rockchip_lvds_bind(struct device *dev, struct device *master,
537 			      void *data)
538 {
539 	struct rockchip_lvds *lvds = dev_get_drvdata(dev);
540 	struct drm_device *drm_dev = data;
541 	struct drm_encoder *encoder;
542 	struct drm_connector *connector;
543 	struct device_node *remote = NULL;
544 	struct device_node  *port, *endpoint;
545 	int ret = 0, child_count = 0;
546 	const char *name;
547 	u32 endpoint_id = 0;
548 
549 	lvds->drm_dev = drm_dev;
550 	port = of_graph_get_port_by_id(dev->of_node, 1);
551 	if (!port) {
552 		DRM_DEV_ERROR(dev,
553 			      "can't found port point, please init lvds panel port!\n");
554 		return -EINVAL;
555 	}
556 	for_each_child_of_node(port, endpoint) {
557 		child_count++;
558 		of_property_read_u32(endpoint, "reg", &endpoint_id);
559 		ret = drm_of_find_panel_or_bridge(dev->of_node, 1, endpoint_id,
560 						  &lvds->panel, &lvds->bridge);
561 		if (!ret) {
562 			of_node_put(endpoint);
563 			break;
564 		}
565 	}
566 	if (!child_count) {
567 		DRM_DEV_ERROR(dev, "lvds port does not have any children\n");
568 		ret = -EINVAL;
569 		goto err_put_port;
570 	} else if (ret) {
571 		DRM_DEV_ERROR(dev, "failed to find panel and bridge node\n");
572 		ret = -EPROBE_DEFER;
573 		goto err_put_port;
574 	}
575 	if (lvds->panel)
576 		remote = lvds->panel->dev->of_node;
577 	else
578 		remote = lvds->bridge->of_node;
579 	if (of_property_read_string(dev->of_node, "rockchip,output", &name))
580 		/* default set it as output rgb */
581 		lvds->output = DISPLAY_OUTPUT_RGB;
582 	else
583 		lvds->output = rockchip_lvds_name_to_output(name);
584 
585 	if (lvds->output < 0) {
586 		DRM_DEV_ERROR(dev, "invalid output type [%s]\n", name);
587 		ret = lvds->output;
588 		goto err_put_remote;
589 	}
590 
591 	if (of_property_read_string(remote, "data-mapping", &name))
592 		/* default set it as format vesa 18 */
593 		lvds->format = LVDS_VESA_18;
594 	else
595 		lvds->format = rockchip_lvds_name_to_format(name);
596 
597 	if (lvds->format < 0) {
598 		DRM_DEV_ERROR(dev, "invalid data-mapping format [%s]\n", name);
599 		ret = lvds->format;
600 		goto err_put_remote;
601 	}
602 
603 	encoder = &lvds->encoder;
604 	encoder->possible_crtcs = drm_of_find_possible_crtcs(drm_dev,
605 							     dev->of_node);
606 
607 	ret = drm_simple_encoder_init(drm_dev, encoder, DRM_MODE_ENCODER_LVDS);
608 	if (ret < 0) {
609 		DRM_DEV_ERROR(drm_dev->dev,
610 			      "failed to initialize encoder: %d\n", ret);
611 		goto err_put_remote;
612 	}
613 
614 	drm_encoder_helper_add(encoder, lvds->soc_data->helper_funcs);
615 
616 	if (lvds->panel) {
617 		connector = &lvds->connector;
618 		connector->dpms = DRM_MODE_DPMS_OFF;
619 		ret = drm_connector_init(drm_dev, connector,
620 					 &rockchip_lvds_connector_funcs,
621 					 DRM_MODE_CONNECTOR_LVDS);
622 		if (ret < 0) {
623 			DRM_DEV_ERROR(drm_dev->dev,
624 				      "failed to initialize connector: %d\n", ret);
625 			goto err_free_encoder;
626 		}
627 
628 		drm_connector_helper_add(connector,
629 					 &rockchip_lvds_connector_helper_funcs);
630 
631 		ret = drm_connector_attach_encoder(connector, encoder);
632 		if (ret < 0) {
633 			DRM_DEV_ERROR(drm_dev->dev,
634 				      "failed to attach encoder: %d\n", ret);
635 			goto err_free_connector;
636 		}
637 	} else {
638 		ret = drm_bridge_attach(encoder, lvds->bridge, NULL, 0);
639 		if (ret) {
640 			DRM_DEV_ERROR(drm_dev->dev,
641 				      "failed to attach bridge: %d\n", ret);
642 			goto err_free_encoder;
643 		}
644 	}
645 
646 	pm_runtime_enable(dev);
647 	of_node_put(remote);
648 	of_node_put(port);
649 
650 	return 0;
651 
652 err_free_connector:
653 	drm_connector_cleanup(connector);
654 err_free_encoder:
655 	drm_encoder_cleanup(encoder);
656 err_put_remote:
657 	of_node_put(remote);
658 err_put_port:
659 	of_node_put(port);
660 
661 	return ret;
662 }
663 
664 static void rockchip_lvds_unbind(struct device *dev, struct device *master,
665 				void *data)
666 {
667 	struct rockchip_lvds *lvds = dev_get_drvdata(dev);
668 	const struct drm_encoder_helper_funcs *encoder_funcs;
669 
670 	encoder_funcs = lvds->soc_data->helper_funcs;
671 	encoder_funcs->disable(&lvds->encoder);
672 	pm_runtime_disable(dev);
673 	drm_connector_cleanup(&lvds->connector);
674 	drm_encoder_cleanup(&lvds->encoder);
675 }
676 
677 static const struct component_ops rockchip_lvds_component_ops = {
678 	.bind = rockchip_lvds_bind,
679 	.unbind = rockchip_lvds_unbind,
680 };
681 
682 static int rockchip_lvds_probe(struct platform_device *pdev)
683 {
684 	struct device *dev = &pdev->dev;
685 	struct rockchip_lvds *lvds;
686 	const struct of_device_id *match;
687 	int ret;
688 
689 	if (!dev->of_node)
690 		return -ENODEV;
691 
692 	lvds = devm_kzalloc(&pdev->dev, sizeof(*lvds), GFP_KERNEL);
693 	if (!lvds)
694 		return -ENOMEM;
695 
696 	lvds->dev = dev;
697 	match = of_match_node(rockchip_lvds_dt_ids, dev->of_node);
698 	if (!match)
699 		return -ENODEV;
700 	lvds->soc_data = match->data;
701 
702 	lvds->grf = syscon_regmap_lookup_by_phandle(dev->of_node,
703 						    "rockchip,grf");
704 	if (IS_ERR(lvds->grf)) {
705 		DRM_DEV_ERROR(dev, "missing rockchip,grf property\n");
706 		return PTR_ERR(lvds->grf);
707 	}
708 
709 	ret = lvds->soc_data->probe(pdev, lvds);
710 	if (ret) {
711 		DRM_DEV_ERROR(dev, "Platform initialization failed\n");
712 		return ret;
713 	}
714 
715 	dev_set_drvdata(dev, lvds);
716 
717 	ret = component_add(&pdev->dev, &rockchip_lvds_component_ops);
718 	if (ret < 0) {
719 		DRM_DEV_ERROR(dev, "failed to add component\n");
720 		clk_unprepare(lvds->pclk);
721 	}
722 
723 	return ret;
724 }
725 
726 static int rockchip_lvds_remove(struct platform_device *pdev)
727 {
728 	struct rockchip_lvds *lvds = dev_get_drvdata(&pdev->dev);
729 
730 	component_del(&pdev->dev, &rockchip_lvds_component_ops);
731 	clk_unprepare(lvds->pclk);
732 
733 	return 0;
734 }
735 
736 struct platform_driver rockchip_lvds_driver = {
737 	.probe = rockchip_lvds_probe,
738 	.remove = rockchip_lvds_remove,
739 	.driver = {
740 		   .name = "rockchip-lvds",
741 		   .of_match_table = of_match_ptr(rockchip_lvds_dt_ids),
742 	},
743 };
744