update kernel to 5.10.198

hc

2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf

 kernel/drivers/mfd/rkx110_x120/rkx110_x120_panel.c
..
..
@@ -21,21 +21,159 @@
21
21
 #include <drm/drm_crtc.h>
22
22
 #include <drm/drm_mipi_dsi.h>
23
23
 #include <drm/drm_panel.h>
24
+#include <drm/drm_atomic_helper.h>
25
+#include <drm/drm_atomic_state_helper.h>
26
+#include <drm/drm_probe_helper.h>
24
27
 
25
28
 #include "rkx110_x120.h"
26
29
 #include "rkx120_dsi_tx.h"
27
30
 
28
-static inline struct rk_serdes_panel *to_serdes_panel(struct drm_panel *panel)
31
+static inline struct rk_serdes_panel *drm_panel_to_serdes_panel(struct drm_panel *panel)
29
32
 {
30
33
 	return container_of(panel, struct rk_serdes_panel, panel);
31
34
 }
32
35
 
33
-static int serdes_panel_prepare(struct drm_panel *panel)
36
+static inline struct rk_serdes_panel *drm_bridge_to_serdes_panel(struct drm_bridge *bridge)
34
37
 {
35
-	struct rk_serdes_panel *sd_panel = to_serdes_panel(panel);
36
-	struct rk_serdes_route *route = &sd_panel->route;
37
-	struct rk_serdes *serdes = sd_panel->parent;
38
+	return container_of(bridge, struct rk_serdes_panel, bridge);
39
+}
38
40
 
41
+static inline struct rk_serdes_panel *drm_connector_to_serdes_panel(struct drm_connector *connector)
42
+{
43
+	return container_of(connector, struct rk_serdes_panel, connector);
44
+}
45
+
46
+static int serdes_connector_get_modes(struct drm_connector *connector)
47
+{
48
+	struct rk_serdes_panel *sd_panel = drm_connector_to_serdes_panel(connector);
49
+
50
+	return drm_panel_get_modes(&sd_panel->panel, connector);
51
+}
52
+
53
+static const struct drm_connector_helper_funcs
54
+rk_serdes_connector_helper_funcs = {
55
+	.get_modes = serdes_connector_get_modes,
56
+};
57
+
58
+static enum drm_connector_status
59
+serdes_connector_detect(struct drm_connector *connector, bool force)
60
+{
61
+	struct rk_serdes_panel *sd_panel = drm_connector_to_serdes_panel(connector);
62
+
63
+	return drm_bridge_detect(&sd_panel->bridge);
64
+}
65
+
66
+static const struct drm_connector_funcs rk_serdes_connector_funcs = {
67
+	.detect = serdes_connector_detect,
68
+	.reset = drm_atomic_helper_connector_reset,
69
+	.fill_modes = drm_helper_probe_single_connector_modes,
70
+	.destroy = drm_connector_cleanup,
71
+	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
72
+	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
73
+};
74
+
75
+static int rk_serdes_bridge_attach(struct drm_bridge *bridge,
76
+				  enum drm_bridge_attach_flags flags)
77
+{
78
+	struct rk_serdes_panel *sd_panel = drm_bridge_to_serdes_panel(bridge);
79
+	struct drm_connector *connector = &sd_panel->connector;
80
+	int ret;
81
+
82
+	if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
83
+		return 0;
84
+
85
+	if (!bridge->encoder) {
86
+		dev_err(sd_panel->dev, "Missing encoder\n");
87
+		return -ENODEV;
88
+	}
89
+
90
+	connector->polled |= DRM_CONNECTOR_POLL_HPD;
91
+	drm_connector_helper_add(connector,
92
+				 &rk_serdes_connector_helper_funcs);
93
+
94
+	ret = drm_connector_init(bridge->dev, connector,
95
+				 &rk_serdes_connector_funcs,
96
+				 sd_panel->connector_type);
97
+	if (ret) {
98
+		dev_err(sd_panel->dev, "Failed to initialize connector\n");
99
+		return ret;
100
+	}
101
+
102
+	drm_connector_attach_encoder(&sd_panel->connector, bridge->encoder);
103
+
104
+	return 0;
105
+}
106
+
107
+static void rk_serdes_bridge_detach(struct drm_bridge *bridge)
108
+{
109
+	struct rk_serdes_panel *sd_panel = drm_bridge_to_serdes_panel(bridge);
110
+	struct drm_connector *connector = &sd_panel->connector;
111
+
112
+	/*
113
+	 * Cleanup the connector if we know it was initialized.
114
+	 */
115
+	if (connector->dev)
116
+		drm_connector_cleanup(connector);
117
+}
118
+
119
+static void rk_serdes_bridge_pre_enable(struct drm_bridge *bridge)
120
+{
121
+	struct rk_serdes_panel *sd_panel = drm_bridge_to_serdes_panel(bridge);
122
+
123
+	drm_panel_prepare(&sd_panel->panel);
124
+}
125
+
126
+static void rk_serdes_bridge_enable(struct drm_bridge *bridge)
127
+{
128
+	struct rk_serdes_panel *sd_panel = drm_bridge_to_serdes_panel(bridge);
129
+
130
+	drm_panel_enable(&sd_panel->panel);
131
+}
132
+
133
+static void rk_serdes_bridge_disable(struct drm_bridge *bridge)
134
+{
135
+	struct rk_serdes_panel *sd_panel = drm_bridge_to_serdes_panel(bridge);
136
+
137
+	drm_panel_disable(&sd_panel->panel);
138
+}
139
+
140
+static void rk_serdes_bridge_post_disable(struct drm_bridge *bridge)
141
+{
142
+	struct rk_serdes_panel *sd_panel = drm_bridge_to_serdes_panel(bridge);
143
+
144
+	drm_panel_unprepare(&sd_panel->panel);
145
+}
146
+
147
+static int rk_serdes_bridge_get_modes(struct drm_bridge *bridge,
148
+				      struct drm_connector *connector)
149
+{
150
+	struct rk_serdes_panel *sd_panel = drm_bridge_to_serdes_panel(bridge);
151
+
152
+	return drm_panel_get_modes(&sd_panel->panel, connector);
153
+}
154
+
155
+static enum drm_connector_status rk_serdes_bridge_detect(struct drm_bridge *bridge)
156
+{
157
+	return connector_status_connected;
158
+}
159
+
160
+static const struct drm_bridge_funcs panel_bridge_bridge_funcs = {
161
+	.attach = rk_serdes_bridge_attach,
162
+	.detach = rk_serdes_bridge_detach,
163
+	.pre_enable = rk_serdes_bridge_pre_enable,
164
+	.enable = rk_serdes_bridge_enable,
165
+	.disable = rk_serdes_bridge_disable,
166
+	.post_disable = rk_serdes_bridge_post_disable,
167
+	.get_modes = rk_serdes_bridge_get_modes,
168
+	.detect = rk_serdes_bridge_detect,
169
+	.atomic_reset = drm_atomic_helper_bridge_reset,
170
+	.atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
171
+	.atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
172
+	.atomic_get_input_bus_fmts = drm_atomic_helper_bridge_propagate_bus_fmt,
173
+};
174
+
175
+static int serdes_panel_hw_prepare(struct rk_serdes_panel *sd_panel)
176
+{
39
177
 	if (sd_panel->supply) {
40
178
 		int err;
41
179
 
..
..
@@ -58,36 +196,84 @@
58
196
 		mdelay(20);
59
197
 	}
60
198
 
199
+	return 0;
200
+}
201
+
202
+static int serdes_panel_dsi_prepare(struct rk_serdes_panel *sd_panel)
203
+{
204
+	struct rk_serdes *serdes = sd_panel->parent;
205
+
206
+	if (sd_panel->id == 0 && sd_panel->route.remote0_port0 == RK_SERDES_DSI_TX0 &&
207
+	    !!(sd_panel->on_cmds))
208
+		rkx120_dsi_tx_cmd_seq_xfer(serdes, &sd_panel->dsi_tx, DEVICE_REMOTE0,
209
+					   sd_panel->on_cmds);
210
+
211
+	if (sd_panel->id == 1 && sd_panel->route.remote1_port0 == RK_SERDES_DSI_TX0 &&
212
+	    !!(sd_panel->on_cmds))
213
+		rkx120_dsi_tx_cmd_seq_xfer(serdes, &sd_panel->dsi_tx, DEVICE_REMOTE1,
214
+					   sd_panel->on_cmds);
215
+
216
+	return 0;
217
+}
218
+
219
+static int serdes_panel_prepare(struct drm_panel *panel)
220
+{
221
+	struct rk_serdes_panel *sd_panel = drm_panel_to_serdes_panel(panel);
222
+	struct rk_serdes *serdes = sd_panel->parent;
223
+	int ret;
224
+
225
+	ret = serdes_panel_hw_prepare(sd_panel);
226
+	if (ret)
227
+		return ret;
228
+	if (sd_panel->secondary) {
229
+		ret = serdes_panel_hw_prepare(sd_panel->secondary);
230
+		if (ret)
231
+			return ret;
232
+	}
233
+
61
234
 	if (serdes->route_prepare)
62
235
 		serdes->route_prepare(serdes, &sd_panel->route);
63
236
 
64
-	if (route->remote0_port0 == RK_SERDES_DSI_TX0 && !!(sd_panel->on_cmds))
65
-		rkx120_dsi_tx_cmd_seq_xfer(serdes, DEVICE_REMOTE0,
66
-					   sd_panel->on_cmds);
67
-
68
-	if (route->remote1_port0 == RK_SERDES_DSI_TX0 && !!(sd_panel->on_cmds))
69
-		rkx120_dsi_tx_cmd_seq_xfer(serdes, DEVICE_REMOTE1,
70
-					   sd_panel->on_cmds);
237
+	serdes_panel_dsi_prepare(sd_panel);
238
+	if (sd_panel->secondary)
239
+		serdes_panel_dsi_prepare(sd_panel->secondary);
71
240
 
72
241
 	return 0;
73
242
 }
74
243
 
75
244
 static int serdes_panel_enable(struct drm_panel *panel)
76
245
 {
77
-	struct rk_serdes_panel *sd_panel = to_serdes_panel(panel);
246
+	struct rk_serdes_panel *sd_panel = drm_panel_to_serdes_panel(panel);
78
247
 	struct rk_serdes *serdes = sd_panel->parent;
248
+	int ret;
79
249
 
80
250
 	if (serdes->route_enable)
81
251
 		serdes->route_enable(serdes, &sd_panel->route);
252
+
253
+	if (sd_panel->secondary) {
254
+		ret = backlight_enable(sd_panel->secondary->panel.backlight);
255
+		if (ret < 0) {
256
+			dev_err(sd_panel->dev, "failed to enable backlight: %d\n", ret);
257
+			return ret;
258
+		}
259
+	}
82
260
 
83
261
 	return 0;
84
262
 }
85
263
 
86
264
 static int serdes_panel_disable(struct drm_panel *panel)
87
265
 {
88
-	struct rk_serdes_panel *sd_panel = to_serdes_panel(panel);
266
+	struct rk_serdes_panel *sd_panel = drm_panel_to_serdes_panel(panel);
89
267
 	struct rk_serdes *serdes = sd_panel->parent;
268
+	int ret;
90
269
 
270
+	if (sd_panel->secondary) {
271
+		ret = backlight_disable(sd_panel->secondary->panel.backlight);
272
+		if (ret < 0) {
273
+			dev_err(sd_panel->dev, "failed to disable backlight: %d\n", ret);
274
+			return ret;
275
+		}
276
+	}
91
277
 
92
278
 	if (serdes->route_disable)
93
279
 		serdes->route_disable(serdes, &sd_panel->route);
..
..
@@ -95,22 +281,8 @@
95
281
 	return 0;
96
282
 }
97
283
 
98
-static int serdes_panel_unprepare(struct drm_panel *panel)
284
+static int serdes_panel_hw_unprepare(struct rk_serdes_panel *sd_panel)
99
285
 {
100
-	struct rk_serdes_panel *sd_panel = to_serdes_panel(panel);
101
-	struct rk_serdes_route *route = &sd_panel->route;
102
-	struct rk_serdes *serdes = sd_panel->parent;
103
-
104
-	if (route->remote0_port0 == RK_SERDES_DSI_TX0 && !!(sd_panel->on_cmds))
105
-		rkx120_dsi_tx_cmd_seq_xfer(serdes, DEVICE_REMOTE0,
106
-					   sd_panel->off_cmds);
107
-
108
-	if (route->remote1_port0 == RK_SERDES_DSI_TX0 && !!(sd_panel->on_cmds))
109
-		rkx120_dsi_tx_cmd_seq_xfer(serdes, DEVICE_REMOTE1,
110
-					   sd_panel->off_cmds);
111
-	if (serdes->route_unprepare)
112
-		serdes->route_unprepare(serdes, &sd_panel->route);
113
-
114
286
 	if (sd_panel->reset_gpio) {
115
287
 		gpiod_set_value_cansleep(sd_panel->reset_gpio, 0);
116
288
 		mdelay(20);
..
..
@@ -123,6 +295,42 @@
123
295
 
124
296
 	if (sd_panel->supply)
125
297
 		regulator_disable(sd_panel->supply);
298
+
299
+	return 0;
300
+}
301
+
302
+static int serdes_panel_dsi_unprepare(struct rk_serdes_panel *sd_panel)
303
+{
304
+	struct rk_serdes *serdes = sd_panel->parent;
305
+
306
+	if (sd_panel->id == 0 && sd_panel->route.remote0_port0 == RK_SERDES_DSI_TX0 &&
307
+	    !!(sd_panel->off_cmds))
308
+		rkx120_dsi_tx_cmd_seq_xfer(serdes, &sd_panel->dsi_tx, DEVICE_REMOTE0,
309
+					   sd_panel->off_cmds);
310
+
311
+	if (sd_panel->id == 1 && sd_panel->route.remote1_port0 == RK_SERDES_DSI_TX0 &&
312
+	    !!(sd_panel->off_cmds))
313
+		rkx120_dsi_tx_cmd_seq_xfer(serdes, &sd_panel->dsi_tx, DEVICE_REMOTE1,
314
+					   sd_panel->off_cmds);
315
+
316
+	return 0;
317
+}
318
+
319
+static int serdes_panel_unprepare(struct drm_panel *panel)
320
+{
321
+	struct rk_serdes_panel *sd_panel = drm_panel_to_serdes_panel(panel);
322
+	struct rk_serdes *serdes = sd_panel->parent;
323
+
324
+	serdes_panel_dsi_unprepare(sd_panel);
325
+	if (sd_panel->secondary)
326
+		serdes_panel_dsi_unprepare(sd_panel->secondary);
327
+
328
+	if (serdes->route_unprepare)
329
+		serdes->route_unprepare(serdes, &sd_panel->route);
330
+
331
+	serdes_panel_hw_unprepare(sd_panel);
332
+	if (sd_panel->secondary)
333
+		serdes_panel_hw_unprepare(sd_panel->secondary);
126
334
 
127
335
 	return 0;
128
336
 }
..
..
@@ -184,7 +392,7 @@
184
392
 static int serdes_panel_get_modes(struct drm_panel *panel,
185
393
 				struct drm_connector *connector)
186
394
 {
187
-	struct rk_serdes_panel *sd_panel = to_serdes_panel(panel);
395
+	struct rk_serdes_panel *sd_panel = drm_panel_to_serdes_panel(panel);
188
396
 	int num = 0;
189
397
 
190
398
 	num += serdes_panel_of_get_native_mode(sd_panel, connector);
..
..
@@ -201,6 +409,52 @@
201
409
 	.unprepare = serdes_panel_unprepare,
202
410
 	.get_modes = serdes_panel_get_modes,
203
411
 };
412
+
413
+static void rk_serdes_panel_get_connector_type(struct rk_serdes_panel *sd_panel)
414
+{
415
+	struct rk_serdes_route *route = &sd_panel->route;
416
+	u32 local_port;
417
+
418
+	if (route->local_port0)
419
+		local_port = route->local_port0;
420
+	else
421
+		local_port = route->local_port1;
422
+
423
+	if ((local_port == RK_SERDES_DSI_RX0) ||
424
+	    (local_port == RK_SERDES_DSI_RX1))
425
+		sd_panel->connector_type = DRM_MODE_CONNECTOR_DSI;
426
+	else if (local_port == RK_SERDES_RGB_RX)
427
+		sd_panel->connector_type = DRM_MODE_CONNECTOR_DPI;
428
+	else
429
+		sd_panel->connector_type = DRM_MODE_CONNECTOR_LVDS;
430
+}
431
+
432
+static int rk_serdes_panel_bridge_add(struct rk_serdes_panel *sd_panel)
433
+{
434
+	int ret;
435
+
436
+	rk_serdes_panel_get_connector_type(sd_panel);
437
+
438
+	sd_panel->bridge.funcs = &panel_bridge_bridge_funcs;
439
+	sd_panel->bridge.of_node = sd_panel->dev->of_node;
440
+	sd_panel->bridge.ops = DRM_BRIDGE_OP_MODES | DRM_BRIDGE_OP_DETECT;
441
+	sd_panel->bridge.type = sd_panel->connector_type;
442
+
443
+	drm_panel_init(&sd_panel->panel, sd_panel->dev, &serdes_panel_funcs, 0);
444
+
445
+	ret = drm_panel_of_backlight(&sd_panel->panel);
446
+	if (ret)
447
+		return ret;
448
+
449
+	drm_bridge_add(&sd_panel->bridge);
450
+
451
+	return 0;
452
+}
453
+
454
+static void rk_serdes_panel_bridge_remove(struct rk_serdes_panel *sd_panel)
455
+{
456
+	drm_bridge_remove(&sd_panel->bridge);
457
+}
204
458
 
205
459
 static int
206
460
 dsi_panel_parse_cmds(struct device *dev, const u8 *data,
..
..
@@ -336,11 +590,10 @@
336
590
 	return dsi;
337
591
 }
338
592
 
339
-static int rkx120_dsi_rx_parse(struct rk_serdes_panel *sd_panel)
593
+static int rkx110_dsi_rx_parse(struct rk_serdes_panel *sd_panel)
340
594
 {
341
595
 	struct device_node *np = sd_panel->dev->of_node;
342
-	struct rk_serdes *serdes = sd_panel->parent;
343
-	struct rkx110_dsi_rx *dsi_rx = &serdes->dsi_rx;
596
+	struct rkx110_dsi_rx *dsi_rx = &sd_panel->dsi_rx;
344
597
 	struct mipi_dsi_device *dsi;
345
598
 	struct device_node *dsi_node;
346
599
 	u32 val;
..
..
@@ -370,11 +623,12 @@
370
623
 static int rkx120_dsi_tx_parse(struct rk_serdes_panel *sd_panel)
371
624
 {
372
625
 	struct device_node *np = sd_panel->dev->of_node;
373
-	struct rk_serdes *serdes = sd_panel->parent;
374
-	struct rkx120_dsi_tx *dsi_tx = &serdes->dsi_tx;
626
+	struct rkx120_dsi_tx *dsi_tx = &sd_panel->dsi_tx;
375
627
 	const char *string;
376
628
 	int ret;
377
629
 	u32 val;
630
+
631
+	dsi_tx->combtxphy = &sd_panel->combtxphy;
378
632
 
379
633
 	if (of_property_read_u32(np, "dsi-tx,lanes", &val))
380
634
 		dsi_tx->lanes = 4;
..
..
@@ -418,12 +672,9 @@
418
672
 	return 0;
419
673
 }
420
674
 
421
-static int serdes_panel_parse_dt(struct rk_serdes_panel *sd_panel)
675
+static int serdes_panel_parse_route(struct rk_serdes_panel *sd_panel)
422
676
 {
423
677
 	struct rk_serdes_route *route = &sd_panel->route;
424
-	struct rk_serdes *serdes = sd_panel->parent;
425
-	u32 lanes;
426
-	int ret;
427
678
 
428
679
 	device_property_read_u32(sd_panel->dev, "local-port0", &route->local_port0);
429
680
 	device_property_read_u32(sd_panel->dev, "local-port1", &route->local_port1);
..
..
@@ -431,17 +682,19 @@
431
682
 	device_property_read_u32(sd_panel->dev, "remote0-port1", &route->remote0_port1);
432
683
 	device_property_read_u32(sd_panel->dev, "remote1-port0", &route->remote1_port0);
433
684
 	device_property_read_u32(sd_panel->dev, "remote1-port1", &route->remote1_port1);
434
-	device_property_read_u32(sd_panel->dev, "num-lanes", &lanes);
435
685
 
436
-	serdes->route_flag = 0;
437
-
438
-	if (!route->local_port0) {
439
-		dev_err(sd_panel->dev, "local_port0 should set\n");
686
+	if (!route->local_port0 && !route->local_port1) {
687
+		dev_err(sd_panel->dev, "local port should set\n");
440
688
 		return -EINVAL;
441
689
 	}
442
690
 
443
-	if (!route->remote0_port0) {
691
+	if (route->local_port0 && !route->remote0_port0) {
444
692
 		dev_err(sd_panel->dev, "remote0_port0 should set\n");
693
+		return -EINVAL;
694
+	}
695
+
696
+	if (route->local_port1 && !route->remote1_port0) {
697
+		dev_err(sd_panel->dev, "remote1_port0 should set\n");
445
698
 		return -EINVAL;
446
699
 	}
447
700
 
..
..
@@ -451,48 +704,28 @@
451
704
 	}
452
705
 
453
706
 	route->frame_mode = SERDES_FRAME_NORMAL_MODE;
707
+	route->route_flag = 0;
454
708
 
455
-	/* 2 video stream output */
456
-	if (route->remote1_port0 || route->remote0_port1) {
709
+	/* 2 video stream output in a route */
710
+	if (route->local_port0 && (route->remote1_port0 || route->remote0_port1)) {
457
711
 		if (route->remote1_port0)
458
-			serdes->route_flag |= ROUTE_MULTI_REMOTE | ROUTE_MULTI_CHANNEL |
712
+			route->route_flag |= ROUTE_MULTI_REMOTE | ROUTE_MULTI_CHANNEL|
459
713
 					     ROUTE_MULTI_LANE;
460
714
 
461
715
 		if (route->remote0_port1) {
462
716
 			if ((route->remote0_port0 == RK_SERDES_LVDS_TX0) &&
463
717
 			    (route->remote0_port1 == RK_SERDES_LVDS_TX1)) {
464
-				serdes->route_flag |= ROUTE_MULTI_CHANNEL;
718
+				route->route_flag |= ROUTE_MULTI_CHANNEL;
465
719
 			} else if ((route->remote0_port0 == RK_SERDES_LVDS_TX1) &&
466
720
 				    (route->remote0_port1 == RK_SERDES_LVDS_TX0)) {
467
-				serdes->route_flag |= ROUTE_MULTI_CHANNEL;
721
+				route->route_flag |= ROUTE_MULTI_CHANNEL;
468
722
 			} else {
469
723
 				dev_err(sd_panel->dev, "invalid multi output type\n");
470
724
 				return -EINVAL;
471
725
 			}
472
-
473
-			if (lanes == 2)
474
-				serdes->route_flag |= ROUTE_MULTI_LANE;
475
726
 		}
476
727
 
477
-		if (route->local_port1) {
478
-			if ((route->local_port0 == RK_SERDES_DSI_RX0) &&
479
-			    (route->local_port1 == RK_SERDES_DSI_RX1))
480
-				serdes->route_flag |= ROUTE_MULTI_DSI_INPUT;
481
-			else if ((route->local_port0 == RK_SERDES_DSI_RX1) &&
482
-				 (route->local_port1 == RK_SERDES_DSI_RX0))
483
-				serdes->route_flag |= ROUTE_MULTI_DSI_INPUT;
484
-			else if ((route->local_port0 == RK_SERDES_LVDS_RX0) &&
485
-				 (route->local_port1 == RK_SERDES_LVDS_RX1))
486
-				serdes->route_flag |= ROUTE_MULTI_LVDS_INPUT;
487
-			else if ((route->local_port0 == RK_SERDES_LVDS_RX1) &&
488
-				 (route->local_port1 == RK_SERDES_LVDS_RX0))
489
-				serdes->route_flag |= ROUTE_MULTI_LVDS_INPUT;
490
-			else {
491
-				dev_err(sd_panel->dev, "invalid multi input type\n");
492
-				return -EINVAL;
493
-			}
494
-			serdes->route_flag |= ROUTE_MULTI_SOURCE;
495
-		} else {
728
+		if (route->local_port0) {
496
729
 			if (device_property_read_bool(sd_panel->dev, "split-mode")) {
497
730
 				/* only dsi input support split mode */
498
731
 				if ((route->local_port0 != RK_SERDES_DSI_RX0) &&
..
..
@@ -510,41 +743,43 @@
510
743
 				else
511
744
 					route->frame_mode = SERDES_SP_LEFT_RIGHT_SPLIT;
512
745
 
513
-				serdes->route_flag |= ROUTE_MULTI_SPLIT;
746
+				route->route_flag |= ROUTE_MULTI_SPLIT;
514
747
 
515
748
 			} else  {
516
-				serdes->route_flag |= ROUTE_MULTI_MIRROR;
749
+				route->route_flag |= ROUTE_MULTI_MIRROR;
517
750
 			}
518
751
 		}
519
-	} else {
520
-		if (lanes == 2)
521
-			serdes->route_flag |= ROUTE_MULTI_LANE;
522
-	}
523
-
524
-	if (route->remote0_port0 & RK_SERDES_DSI_TX0 ||
525
-	    route->remote1_port0 & RK_SERDES_DSI_TX0) {
526
-		ret = rkx120_dsi_tx_parse(sd_panel);
527
-		if (ret) {
528
-			dev_err(sd_panel->dev, "failed to get cmds\n");
529
-			return ret;
530
-		}
531
-	}
532
-
533
-	if (route->local_port0 & RK_SERDES_DSI_RX0 ||
534
-	    route->local_port0 & RK_SERDES_DSI_TX1) {
535
-		ret = rkx120_dsi_rx_parse(sd_panel);
536
-		if (ret < 0)
537
-			return ret;
538
752
 	}
539
753
 
540
754
 	return 0;
541
755
 }
542
756
 
757
+static int serdes_panel_match_by_id(struct device *dev, const void *data)
758
+{
759
+	struct rk_serdes_panel *sd_panel = dev_get_drvdata(dev);
760
+	unsigned int *id = (unsigned int *)data;
761
+
762
+	return sd_panel->id == *id;
763
+}
764
+
765
+static struct rk_serdes_panel *serdes_panel_find_by_id(struct device_driver *drv,
766
+						       unsigned int id)
767
+{
768
+	struct device *dev;
769
+
770
+	dev = driver_find_device(drv, NULL, &id, serdes_panel_match_by_id);
771
+	if (!dev)
772
+		return NULL;
773
+
774
+	return dev_get_drvdata(dev);
775
+}
776
+
543
777
 static int serdes_panel_probe(struct platform_device *pdev)
544
778
 {
545
779
 	struct rk_serdes *serdes = dev_get_drvdata(pdev->dev.parent);
546
-	struct rk_serdes_panel *sd_panel;
780
+	struct rk_serdes_panel *sd_panel, *secondary;
547
781
 	int ret;
782
+	u32 reg;
548
783
 
549
784
 	sd_panel = devm_kzalloc(&pdev->dev, sizeof(*sd_panel), GFP_KERNEL);
550
785
 	if (!sd_panel)
..
..
@@ -553,7 +788,20 @@
553
788
 	sd_panel->dev = &pdev->dev;
554
789
 	sd_panel->parent = serdes;
555
790
 	sd_panel->route.stream_type = STREAM_DISPLAY;
556
-	serdes->vm = &sd_panel->route.vm;
791
+
792
+	ret = of_property_read_u32(sd_panel->dev->of_node, "reg", &reg);
793
+	if (ret)
794
+		sd_panel->id = 0;
795
+	sd_panel->id = reg;
796
+
797
+	sd_panel->multi_panel = device_property_read_bool(sd_panel->dev, "multi-panel");
798
+	if (sd_panel->multi_panel) {
799
+		secondary = serdes_panel_find_by_id(sd_panel->dev->driver, 1);
800
+		if (!secondary)
801
+			return -EPROBE_DEFER;
802
+		sd_panel->secondary = secondary;
803
+		dev_info(sd_panel->dev, "%s get secondary panel\n", __func__);
804
+	}
557
805
 
558
806
 	sd_panel->supply = devm_regulator_get_optional(sd_panel->dev, "power");
559
807
 	if (IS_ERR(sd_panel->supply)) {
..
..
@@ -588,22 +836,58 @@
588
836
 		return ret;
589
837
 	}
590
838
 
591
-	/* Register the panel. */
592
-	drm_panel_init(&sd_panel->panel, sd_panel->dev, &serdes_panel_funcs, 0);
839
+	ret = serdes_panel_parse_route(sd_panel);
840
+	if (ret < 0)
841
+		return ret;
593
842
 
594
-	ret = drm_panel_of_backlight(&sd_panel->panel);
843
+	if (sd_panel->route.remote0_port0 & RK_SERDES_DSI_TX0 ||
844
+		sd_panel->route.remote1_port0 & RK_SERDES_DSI_TX0) {
845
+		ret = rkx120_dsi_tx_parse(sd_panel);
846
+		if (ret) {
847
+			dev_err(sd_panel->dev, "failed to get cmds\n");
848
+			return ret;
849
+		}
850
+	}
851
+
852
+	ret = rk_serdes_panel_bridge_add(sd_panel);
595
853
 	if (ret)
596
854
 		return ret;
597
855
 
598
-	drm_panel_add(&sd_panel->panel);
856
+	if ((sd_panel->route.local_port0 & RK_SERDES_DSI_RX0 ||
857
+	    sd_panel->route.local_port0 & RK_SERDES_DSI_RX1) && sd_panel->id == 0) {
858
+		ret = rkx110_dsi_rx_parse(sd_panel);
859
+		if (ret < 0) {
860
+			rk_serdes_panel_bridge_remove(sd_panel);
861
+			return ret;
862
+		}
863
+	}
864
+
865
+	if ((sd_panel->route.local_port1 & RK_SERDES_DSI_RX0 ||
866
+		sd_panel->route.local_port1 & RK_SERDES_DSI_RX1) && sd_panel->id == 1) {
867
+		ret = rkx110_dsi_rx_parse(sd_panel);
868
+		if (ret < 0) {
869
+			rk_serdes_panel_bridge_remove(sd_panel);
870
+			return ret;
871
+		}
872
+	}
599
873
 
600
874
 	dev_set_drvdata(sd_panel->dev, sd_panel);
601
875
 
602
-	ret = serdes_panel_parse_dt(sd_panel);
603
-	if (ret < 0) {
604
-		drm_panel_remove(&sd_panel->panel);
605
-		return ret;
876
+	if (sd_panel->route.route_flag & ROUTE_MULTI_CHANNEL)
877
+		serdes->channel_nr = 2;
878
+
879
+	if (sd_panel->route.local_port0 && sd_panel->id == 0) {
880
+		serdes->route[0] = &sd_panel->route;
881
+		serdes->route_nr++;
606
882
 	}
883
+
884
+	if (sd_panel->route.local_port1 && sd_panel->id == 1) {
885
+		serdes->route[1] = &sd_panel->route;
886
+		serdes->route_nr++;
887
+	}
888
+
889
+	if (serdes->route_nr == 2)
890
+		serdes->channel_nr = 2;
607
891
 
608
892
 	return 0;
609
893
 }
..
..
@@ -612,7 +896,7 @@
612
896
 {
613
897
 	struct rk_serdes_panel *sd_panel = dev_get_drvdata(&pdev->dev);
614
898
 
615
-	drm_panel_remove(&sd_panel->panel);
899
+	rk_serdes_panel_bridge_remove(sd_panel);
616
900
 
617
901
 	drm_panel_disable(&sd_panel->panel);
618
902
 
..
..
@@ -630,7 +914,7 @@
630
914
 	.probe		= serdes_panel_probe,
631
915
 	.remove		= serdes_panel_remove,
632
916
 	.driver		= {
633
-		.name	= "serdes-panel",
917
+		.name	= "rockchip-serdes-panel",
634
918
 		.of_match_table = serdes_panel_of_table,
635
919
 	},
636
920
 };