forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-01-03 2f7c68cb55ecb7331f2381deb497c27155f32faf 
 kernel/drivers/mfd/rkx110_x120/rkx110_x120_core.c
....@@ -10,9 +10,12 @@
1010 #include <linux/init.h>
1111 #include <linux/interrupt.h>
1212 #include <linux/i2c.h>
13
+#include <linux/irq.h>
1314 #include <linux/gpio/consumer.h>
15
+#include <linux/regulator/consumer.h>
1416 #include <linux/mfd/core.h>
1517 #include "rkx110_x120.h"
18
+#include "rkx110_x120_display.h"
1619 #include "rkx110_reg.h"
1720 #include "rkx110_dsi_rx.h"
1821 #include "rkx120_dsi_tx.h"
....@@ -22,8 +25,44 @@
2225 static const struct mfd_cell rkx110_x120_devs[] = {
2326 	/* 2 panel device for rkx110_x120 drm panel */
2427 	{
25
-		.name = "serdes-panel",
28
+		.name = "rockchip-serdes-panel",
2629 		.of_compatible = "rockchip,serdes-panel",
30
+	},
31
+	{
32
+		.name = "rockchip-serdes-panel1",
33
+		.of_compatible = "rockchip,serdes-panel",
34
+	},
35
+	{
36
+		.name = "rkx120-pwm0",
37
+		.of_compatible = "rockchip,rkx120-pwm",
38
+	},
39
+	{
40
+		.name = "rkx120-pwm1",
41
+		.of_compatible = "rockchip,rkx120-pwm",
42
+	},
43
+	{
44
+		.name = "rkx120-pwm2",
45
+		.of_compatible = "rockchip,rkx120-pwm",
46
+	},
47
+	{
48
+		.name = "rkx120-pwm3",
49
+		.of_compatible = "rockchip,rkx120-pwm",
50
+	},
51
+	{
52
+		.name = "rkx120-pwm4",
53
+		.of_compatible = "rockchip,rkx120-pwm",
54
+	},
55
+	{
56
+		.name = "rkx120-pwm5",
57
+		.of_compatible = "rockchip,rkx120-pwm",
58
+	},
59
+	{
60
+		.name = "rkx120-pwm6",
61
+		.of_compatible = "rockchip,rkx120-pwm",
62
+	},
63
+	{
64
+		.name = "rkx120-pwm7",
65
+		.of_compatible = "rockchip,rkx120-pwm",
2766 	},
2867 };
2968 
....@@ -111,26 +150,40 @@
111150 	return serdes->rkx110_debug || serdes->rkx120_debug;
112151 }
113152 
114
-static void rk_serdes_wait_link_ready(struct rk_serdes *serdes)
153
+static int rk_serdes_wait_link_ready(struct rk_serdes *serdes)
115154 {
155
+	int ret;
156
+
116157 	if (serdes->stream_type == STREAM_DISPLAY) {
117
-		rkx110_linktx_wait_link_ready(serdes, 0);
118
-		if (serdes->route_flag & ROUTE_MULTI_LANE) {
158
+		ret = rkx110_linktx_wait_link_ready(serdes, 0);
159
+		if (ret)
160
+			return ret;
161
+
162
+		if (serdes->lane_nr == 2) {
119163 			rkx110_ser_pma_enable(serdes, true, 1, DEVICE_LOCAL);
120
-			if (!(serdes->route_flag & ROUTE_MULTI_REMOTE))
164
+			if (!(serdes->remote_nr == 2))
121165 				rkx120_des_pma_enable(serdes, true, 1, DEVICE_REMOTE0);
122
-			rkx110_linktx_wait_link_ready(serdes, 1);
166
+			ret = rkx110_linktx_wait_link_ready(serdes, 1);
167
+			if (ret)
168
+				return ret;
123169 		}
124170 
125171 	} else {
126
-		rkx120_linkrx_wait_link_ready(serdes, 0);
127
-		if (serdes->route_flag & ROUTE_MULTI_LANE) {
172
+		ret = rkx120_linkrx_wait_link_ready(serdes, 0);
173
+		if (ret)
174
+			return ret;
175
+
176
+		if (serdes->lane_nr == 2) {
128177 			rkx120_des_pma_enable(serdes, true, 1, DEVICE_LOCAL);
129
-			if (!(serdes->route_flag & ROUTE_MULTI_REMOTE))
178
+			if (!(serdes->remote_nr == 2))
130179 				rkx110_ser_pma_enable(serdes, true, 1, DEVICE_REMOTE0);
131
-			rkx120_linkrx_wait_link_ready(serdes, 1);
180
+			ret = rkx120_linkrx_wait_link_ready(serdes, 1);
181
+			if (ret)
182
+				return ret;
132183 		}
133184 	}
185
+
186
+	return 0;
134187 }
135188 
136189 static void rk_serdes_print_rate(struct rk_serdes *serdes, enum rk_serdes_rate rate)
....@@ -302,9 +355,9 @@
302355 	if (serdes->stream_type == STREAM_DISPLAY) {
303356 		rkx110_pma_set_rate(serdes, &rkx110_pll, 0, DEVICE_LOCAL);
304357 		rkx120_pma_set_rate(serdes, &rkx120_pll, 0, DEVICE_REMOTE0);
305
-		if (serdes->route_flag & ROUTE_MULTI_LANE) {
358
+		if (serdes->lane_nr == 2) {
306359 			rkx110_pma_set_rate(serdes, &rkx110_pll, 1, DEVICE_LOCAL);
307
-			if (serdes->route_flag & ROUTE_MULTI_REMOTE)
360
+			if (serdes->remote_nr == 2)
308361 				rkx120_pma_set_rate(serdes, &rkx120_pll, 0, DEVICE_REMOTE1);
309362 			else
310363 				rkx120_pma_set_rate(serdes, &rkx120_pll, 1, DEVICE_REMOTE0);
....@@ -315,9 +368,9 @@
315368 	} else {
316369 		rkx120_pma_set_rate(serdes, &rkx120_pll, 0, DEVICE_LOCAL);
317370 		rkx110_pma_set_rate(serdes, &rkx110_pll, 0, DEVICE_REMOTE0);
318
-		if (serdes->route_flag & ROUTE_MULTI_LANE) {
371
+		if (serdes->lane_nr == 2) {
319372 			rkx120_pma_set_rate(serdes, &rkx120_pll, 1, DEVICE_LOCAL);
320
-			if (serdes->route_flag & ROUTE_MULTI_REMOTE)
373
+			if (serdes->remote_nr == 2)
321374 				rkx110_pma_set_rate(serdes, &rkx110_pll, 0, DEVICE_REMOTE1);
322375 			else
323376 				rkx110_pma_set_rate(serdes, &rkx110_pll, 1, DEVICE_REMOTE0);
....@@ -330,225 +383,6 @@
330383 	rk_serdes_wait_link_ready(serdes);
331384 
332385 	serdes->rate = rate;
333
-}
334
-
335
-static int rk_serdes_route_prepare(struct rk_serdes *serdes, struct rk_serdes_route *route)
336
-{
337
-	if (rk_serdes_debug_mode(serdes))
338
-		return 0;
339
-
340
-	if (route->stream_type == STREAM_DISPLAY) {
341
-		switch (route->local_port0) {
342
-		case RK_SERDES_RGB_RX:
343
-			rkx110_rgb_rx_enable(serdes, route);
344
-			break;
345
-		case RK_SERDES_LVDS_RX0:
346
-			rkx110_lvds_rx_enable(serdes, route, 0);
347
-			if (serdes->route_flag & ROUTE_MULTI_LVDS_INPUT)
348
-				rkx110_lvds_rx_enable(serdes, route, 1);
349
-			break;
350
-		case RK_SERDES_LVDS_RX1:
351
-			rkx110_lvds_rx_enable(serdes, route, 1);
352
-			if (serdes->route_flag & ROUTE_MULTI_LVDS_INPUT)
353
-				rkx110_lvds_rx_enable(serdes, route, 0);
354
-			break;
355
-		case RK_SERDES_DUAL_LVDS_RX:
356
-			rkx110_lvds_rx_enable(serdes, route, 0);
357
-			rkx110_lvds_rx_enable(serdes, route, 1);
358
-			break;
359
-		case RK_SERDES_DSI_RX0:
360
-			rkx110_dsi_rx_enable(serdes, route, 0);
361
-			if (serdes->route_flag & ROUTE_MULTI_DSI_INPUT)
362
-				rkx110_dsi_rx_enable(serdes, route, 1);
363
-			break;
364
-		case RK_SERDES_DSI_RX1:
365
-			rkx110_dsi_rx_enable(serdes, route, 1);
366
-			if (serdes->route_flag & ROUTE_MULTI_DSI_INPUT)
367
-				rkx110_dsi_rx_enable(serdes, route, 0);
368
-			break;
369
-		default:
370
-			dev_info(serdes->dev, "undefined local port0");
371
-			return -EINVAL;
372
-		}
373
-
374
-		rkx110_linktx_enable(serdes, route);
375
-
376
-		rkx120_linkrx_enable(serdes, route, DEVICE_REMOTE0);
377
-		if (serdes->route_flag & ROUTE_MULTI_REMOTE)
378
-			rkx120_linkrx_enable(serdes, route, DEVICE_REMOTE1);
379
-
380
-		if (route->remote0_port0 & RK_SERDES_DSI_TX0)
381
-			rkx120_dsi_tx_pre_enable(serdes, route, DEVICE_REMOTE0);
382
-		if (route->remote1_port0 & RK_SERDES_DSI_TX0)
383
-			rkx120_dsi_tx_pre_enable(serdes, route, DEVICE_REMOTE1);
384
-	} else {
385
-		/* for camera stream */
386
-	}
387
-
388
-	return 0;
389
-}
390
-
391
-static int rk_serdes_route_enable(struct rk_serdes *serdes, struct rk_serdes_route *route)
392
-{
393
-	if (rk_serdes_debug_mode(serdes))
394
-		return 0;
395
-
396
-	if (route->stream_type == STREAM_DISPLAY) {
397
-		switch (route->remote0_port0) {
398
-		case RK_SERDES_RGB_TX:
399
-			rkx120_rgb_tx_enable(serdes, route, DEVICE_REMOTE0);
400
-			break;
401
-		case RK_SERDES_LVDS_TX0:
402
-			rkx120_lvds_tx_enable(serdes, route, DEVICE_REMOTE0, 0);
403
-			break;
404
-		case RK_SERDES_LVDS_TX1:
405
-			rkx120_lvds_tx_enable(serdes, route, DEVICE_REMOTE0, 1);
406
-			break;
407
-		case RK_SERDES_DUAL_LVDS_TX:
408
-			rkx120_lvds_tx_enable(serdes, route, DEVICE_REMOTE0, 0);
409
-			rkx120_lvds_tx_enable(serdes, route, DEVICE_REMOTE0, 1);
410
-			break;
411
-		case RK_SERDES_DSI_TX0:
412
-			rkx120_dsi_tx_enable(serdes, route, DEVICE_REMOTE0);
413
-			break;
414
-		default:
415
-			dev_err(serdes->dev, "undefined remote0_port0\n");
416
-			return -EINVAL;
417
-		}
418
-
419
-		if (serdes->route_flag & ROUTE_MULTI_REMOTE) {
420
-			switch (route->remote1_port0) {
421
-			case RK_SERDES_RGB_TX:
422
-				rkx120_rgb_tx_enable(serdes, route, DEVICE_REMOTE1);
423
-				break;
424
-			case RK_SERDES_LVDS_TX0:
425
-				rkx120_lvds_tx_enable(serdes, route, DEVICE_REMOTE1, 0);
426
-				break;
427
-			case RK_SERDES_LVDS_TX1:
428
-				rkx120_lvds_tx_enable(serdes, route, DEVICE_REMOTE1, 1);
429
-				break;
430
-			case RK_SERDES_DUAL_LVDS_TX:
431
-				rkx120_lvds_tx_enable(serdes, route, DEVICE_REMOTE1, 0);
432
-				rkx120_lvds_tx_enable(serdes, route, DEVICE_REMOTE1, 1);
433
-				break;
434
-			case RK_SERDES_DSI_TX0:
435
-				rkx120_dsi_tx_enable(serdes, route, DEVICE_REMOTE1);
436
-				break;
437
-			default:
438
-				dev_err(serdes->dev, "undefined remote1_port0\n");
439
-				return -EINVAL;
440
-			}
441
-		} else if (serdes->route_flag & ROUTE_MULTI_CHANNEL) {
442
-			if (route->remote0_port1 & RK_SERDES_LVDS_TX0) {
443
-				rkx120_lvds_tx_enable(serdes, route, DEVICE_REMOTE0, 0);
444
-			} else if (route->remote0_port1 & RK_SERDES_LVDS_TX1) {
445
-				rkx120_lvds_tx_enable(serdes, route, DEVICE_REMOTE0, 1);
446
-			} else {
447
-				dev_err(serdes->dev, "undefined remote0_port1\n");
448
-				return -EINVAL;
449
-			}
450
-		}
451
-
452
-		if (serdes->version == SERDES_V1) {
453
-			rkx120_linkrx_engine_enable(serdes, 0, DEVICE_REMOTE0, true);
454
-			rkx110_linktx_channel_enable(serdes, 0, DEVICE_LOCAL, true);
455
-		}
456
-
457
-		rkx110_linktx_video_enable(serdes, DEVICE_LOCAL, true);
458
-	} else {
459
-		/* for camera stream */
460
-	}
461
-
462
-	return 0;
463
-}
464
-
465
-static int rk_serdes_route_disable(struct rk_serdes *serdes, struct rk_serdes_route *route)
466
-{
467
-	if (route->stream_type == STREAM_DISPLAY) {
468
-		if (route->remote0_port0 & RK_SERDES_DSI_TX0)
469
-			rkx120_dsi_tx_disable(serdes, route, DEVICE_REMOTE0);
470
-
471
-		if (serdes->version == SERDES_V1) {
472
-			rkx120_linkrx_engine_enable(serdes, 0, DEVICE_REMOTE0, false);
473
-			rkx110_linktx_channel_enable(serdes, 0, DEVICE_LOCAL, false);
474
-
475
-			if (route->local_port0 == RK_SERDES_DUAL_LVDS_RX) {
476
-				rkx110_set_stream_source(serdes, RK_SERDES_RGB_RX,
477
-							 DEVICE_LOCAL);
478
-				hwclk_reset(serdes->chip[DEVICE_LOCAL].hwclk,
479
-					    RKX110_SRST_RESETN_2X_LVDS_RKLINK_TX);
480
-				hwclk_reset(serdes->chip[DEVICE_LOCAL].hwclk,
481
-					    RKX110_SRST_RESETN_D_LVDS0_RKLINK_TX);
482
-				hwclk_reset(serdes->chip[DEVICE_LOCAL].hwclk,
483
-					    RKX110_SRST_RESETN_D_LVDS1_RKLINK_TX);
484
-			}
485
-
486
-			if ((route->local_port0 == RK_SERDES_DSI_RX0) ||
487
-			    (route->local_port1 == RK_SERDES_DSI_RX0)) {
488
-				serdes->i2c_write_reg(serdes->chip[DEVICE_LOCAL].client, 0x0314,
489
-						      0x1400140);
490
-				hwclk_reset(serdes->chip[DEVICE_LOCAL].hwclk,
491
-					    RKX111_SRST_RESETN_D_DSI_0_REC_RKLINK_TX);
492
-				hwclk_reset(serdes->chip[DEVICE_LOCAL].hwclk,
493
-					    RKX110_SRST_RESETN_D_DSI_0_RKLINK_TX);
494
-			}
495
-
496
-			if ((route->local_port0 == RK_SERDES_DSI_RX1) ||
497
-			    (route->local_port1 == RK_SERDES_DSI_RX1)) {
498
-				serdes->i2c_write_reg(serdes->chip[DEVICE_LOCAL].client, 0x0314,
499
-						      0x2800280);
500
-				hwclk_reset(serdes->chip[DEVICE_LOCAL].hwclk,
501
-					    RKX111_SRST_RESETN_D_DSI_1_REC_RKLINK_TX);
502
-				hwclk_reset(serdes->chip[DEVICE_LOCAL].hwclk,
503
-					    RKX110_SRST_RESETN_D_DSI_1_RKLINK_TX);
504
-			}
505
-		}
506
-	}
507
-
508
-	return 0;
509
-}
510
-
511
-static int rk_serdes_route_unprepare(struct rk_serdes *serdes, struct rk_serdes_route *route)
512
-{
513
-	if (route->stream_type == STREAM_DISPLAY) {
514
-		if (route->remote0_port0 & RK_SERDES_DSI_TX0)
515
-			rkx120_dsi_tx_post_disable(serdes, route, DEVICE_REMOTE0);
516
-
517
-		if (serdes->version == SERDES_V1) {
518
-			if (route->local_port0 == RK_SERDES_DUAL_LVDS_RX) {
519
-				hwclk_reset_deassert(serdes->chip[DEVICE_LOCAL].hwclk,
520
-						     RKX110_SRST_RESETN_2X_LVDS_RKLINK_TX);
521
-				hwclk_reset_deassert(serdes->chip[DEVICE_LOCAL].hwclk,
522
-						     RKX110_SRST_RESETN_D_LVDS0_RKLINK_TX);
523
-				hwclk_reset_deassert(serdes->chip[DEVICE_LOCAL].hwclk,
524
-						     RKX110_SRST_RESETN_D_LVDS1_RKLINK_TX);
525
-				rkx110_set_stream_source(serdes, RK_SERDES_DUAL_LVDS_RX,
526
-							    DEVICE_LOCAL);
527
-			}
528
-
529
-			if ((route->local_port0 == RK_SERDES_DSI_RX0) ||
530
-			    (route->local_port1 == RK_SERDES_DSI_RX0)) {
531
-				hwclk_reset_deassert(serdes->chip[DEVICE_LOCAL].hwclk,
532
-						     RKX110_SRST_RESETN_D_DSI_0_RKLINK_TX);
533
-				hwclk_reset_deassert(serdes->chip[DEVICE_LOCAL].hwclk,
534
-						     RKX111_SRST_RESETN_D_DSI_0_REC_RKLINK_TX);
535
-				serdes->i2c_write_reg(serdes->chip[DEVICE_LOCAL].client, 0x0314,
536
-						      0x1400000);
537
-			}
538
-
539
-			if ((route->local_port0 == RK_SERDES_DSI_RX1) ||
540
-			    (route->local_port1 == RK_SERDES_DSI_RX1)) {
541
-				hwclk_reset_deassert(serdes->chip[DEVICE_LOCAL].hwclk,
542
-						     RKX110_SRST_RESETN_D_DSI_1_RKLINK_TX);
543
-				hwclk_reset_deassert(serdes->chip[DEVICE_LOCAL].hwclk,
544
-						     RKX111_SRST_RESETN_D_DSI_1_REC_RKLINK_TX);
545
-				serdes->i2c_write_reg(serdes->chip[DEVICE_LOCAL].client, 0x0314,
546
-						      0x2800000);
547
-			}
548
-		}
549
-	}
550
-
551
-	return 0;
552386 }
553387 
554388 static int rk_serdes_set_hwpin(struct rk_serdes *serdes, struct i2c_client *client,
....@@ -576,11 +410,17 @@
576410 	serdes->i2c_read_reg = rk_serdes_i2c_read;
577411 	serdes->i2c_write_reg = rk_serdes_i2c_write;
578412 	serdes->i2c_update_bits = rk_serdes_i2c_update_bits;
579
-	serdes->route_prepare = rk_serdes_route_prepare;
580
-	serdes->route_enable = rk_serdes_route_enable;
581
-	serdes->route_disable = rk_serdes_route_disable;
582
-	serdes->route_unprepare = rk_serdes_route_unprepare;
583413 	serdes->set_hwpin = rk_serdes_set_hwpin;
414
+
415
+	if (rk_serdes_debug_mode(serdes))
416
+		return;
417
+
418
+	if (serdes->stream_type == STREAM_DISPLAY) {
419
+		serdes->route_prepare = rk_serdes_display_route_prepare;
420
+		serdes->route_enable = rk_serdes_display_route_enable;
421
+		serdes->route_disable = rk_serdes_display_route_disable;
422
+		serdes->route_unprepare = rk_serdes_display_route_unprepare;
423
+	}
584424 }
585425 
586426 static int rk_serdes_passthrough_init(struct rk_serdes *serdes)
....@@ -649,6 +489,25 @@
649489 		}
650490 
651491 		kfree(configs);
492
+	}
493
+
494
+	/* config irq passthrough */
495
+	if (serdes->stream_type == STREAM_DISPLAY) {
496
+		rkx110_linktx_passthrough_cfg(serdes, DEVICE_LOCAL, RK_SERDES_PASSTHROUGH_IRQ,
497
+					      false);
498
+		rkx120_linkrx_passthrough_cfg(serdes, DEVICE_REMOTE0, RK_SERDES_PASSTHROUGH_IRQ,
499
+					      true);
500
+		if (serdes->remote_nr == 2)
501
+			rkx120_linkrx_passthrough_cfg(serdes, DEVICE_REMOTE1,
502
+						      RK_SERDES_PASSTHROUGH_IRQ, true);
503
+	} else {
504
+		rkx120_linkrx_passthrough_cfg(serdes, DEVICE_LOCAL, RK_SERDES_PASSTHROUGH_IRQ,
505
+					      false);
506
+		rkx110_linktx_passthrough_cfg(serdes, DEVICE_REMOTE0, RK_SERDES_PASSTHROUGH_IRQ,
507
+					      true);
508
+		if (serdes->remote_nr == 2)
509
+			rkx110_linktx_passthrough_cfg(serdes, DEVICE_REMOTE1,
510
+						      RK_SERDES_PASSTHROUGH_IRQ, true);
652511 	}
653512 
654513 	return 0;
....@@ -903,6 +762,9 @@
903762 		i2c_set_clientdata(client, serdes);
904763 	}
905764 
765
+	if (serdes->remote_nr == 2)
766
+		serdes->lane_nr = 2;
767
+
906768 	if (serdes->remote_nr == 0)
907769 		return -ENODEV;
908770 
....@@ -952,14 +814,73 @@
952814 		kfree(configs);
953815 	}
954816 
817
+	/* config irq pinctrl */
818
+	if (serdes->stream_type == STREAM_DISPLAY) {
819
+		serdes->set_hwpin(serdes, serdes->chip[DEVICE_LOCAL].client, PIN_RKX110,
820
+				  RK_SERDES_SER_GPIO_BANK0, RK_SERDES_GPIO_PIN_A4,
821
+				  RK_SERDES_PIN_CONFIG_MUX_FUNC2);
822
+		serdes->set_hwpin(serdes, serdes->chip[DEVICE_REMOTE0].client, PIN_RKX120,
823
+				  RK_SERDES_DES_GPIO_BANK0, RK_SERDES_GPIO_PIN_A4,
824
+				  RK_SERDES_PIN_CONFIG_MUX_FUNC0);
825
+		if (serdes->remote_nr == 2)
826
+			serdes->set_hwpin(serdes, serdes->chip[DEVICE_REMOTE1].client, PIN_RKX120,
827
+					  RK_SERDES_DES_GPIO_BANK0, RK_SERDES_GPIO_PIN_A4,
828
+					  RK_SERDES_PIN_CONFIG_MUX_FUNC0);
829
+	} else {
830
+		serdes->set_hwpin(serdes, serdes->chip[DEVICE_REMOTE0].client, PIN_RKX110,
831
+				  RK_SERDES_SER_GPIO_BANK0, RK_SERDES_GPIO_PIN_A4,
832
+				  RK_SERDES_PIN_CONFIG_MUX_FUNC0);
833
+		serdes->set_hwpin(serdes, serdes->chip[DEVICE_LOCAL].client, PIN_RKX120,
834
+				  RK_SERDES_DES_GPIO_BANK0, RK_SERDES_GPIO_PIN_A4,
835
+				  RK_SERDES_PIN_CONFIG_MUX_FUNC2);
836
+		if (serdes->remote_nr == 2)
837
+			serdes->set_hwpin(serdes, serdes->chip[DEVICE_REMOTE1].client, PIN_RKX110,
838
+					  RK_SERDES_SER_GPIO_BANK0, RK_SERDES_GPIO_PIN_A4,
839
+					  RK_SERDES_PIN_CONFIG_MUX_FUNC2);
840
+	}
841
+
955842 	return 0;
843
+}
844
+
845
+static int rk_serdes_irq_enable(struct rk_serdes *serdes)
846
+{
847
+	if (serdes->stream_type == STREAM_DISPLAY)
848
+		rkx110_irq_enable(serdes, DEVICE_LOCAL);
849
+	else
850
+		rkx120_irq_enable(serdes, DEVICE_LOCAL);
851
+
852
+	return 0;
853
+}
854
+
855
+__maybe_unused static int rk_serdes_irq_disable(struct rk_serdes *serdes)
856
+{
857
+	if (serdes->stream_type == STREAM_DISPLAY)
858
+		rkx110_irq_disable(serdes, DEVICE_LOCAL);
859
+	else
860
+		rkx120_irq_disable(serdes, DEVICE_LOCAL);
861
+
862
+	return 0;
863
+}
864
+
865
+static irqreturn_t rk_serdes_irq_handler(int irq, void *arg)
866
+{
867
+	struct rk_serdes *serdes = arg;
868
+
869
+	if (serdes->stream_type == STREAM_DISPLAY)
870
+		rkx110_irq_handler(serdes, DEVICE_LOCAL);
871
+	else
872
+		rkx120_irq_handler(serdes, DEVICE_LOCAL);
873
+
874
+	return IRQ_HANDLED;
956875 }
957876 
958877 static int rk_serdes_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
959878 {
960879 	struct device *dev = &client->dev;
880
+	struct device_node *disp_np;
961881 	struct rk_serdes *serdes;
962882 	int ret;
883
+	bool dual_lane;
963884 
964885 	serdes = devm_kzalloc(dev, sizeof(*serdes), GFP_KERNEL);
965886 	if (!serdes)
....@@ -988,6 +909,16 @@
988909 
989910 	serdes->rate = RATE_2GBPS_83M;
990911 
912
+	serdes->supply = devm_regulator_get_optional(dev, "power");
913
+	if (IS_ERR(serdes->supply)) {
914
+		ret = PTR_ERR(serdes->supply);
915
+
916
+		if (ret != -ENODEV)
917
+			return dev_err_probe(dev, ret, "failed to request regulator\n");
918
+
919
+		serdes->supply = NULL;
920
+	}
921
+
991922 	serdes->enable = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_LOW);
992923 	if (IS_ERR(serdes->enable)) {
993924 		ret = PTR_ERR(serdes->enable);
....@@ -1002,15 +933,34 @@
1002933 		return ret;
1003934 	}
1004935 
1005
-	gpiod_set_value(serdes->enable, 1);
936
+	serdes->irq_gpio = devm_gpiod_get_optional(dev, "irq", GPIOD_IN);
937
+	if (IS_ERR(serdes->irq_gpio)) {
938
+		ret = PTR_ERR(serdes->irq_gpio);
939
+		dev_err(dev, "failed to request irq GPIO: %d\n", ret);
940
+		return ret;
941
+	}
942
+	if (serdes->irq_gpio) {
943
+		serdes->irq = gpiod_to_irq(serdes->irq_gpio);
944
+		if (serdes->irq < 0)
945
+			return dev_err_probe(dev, serdes->irq, "failed to get irq\n");
1006946 
1007
-	gpiod_set_value(serdes->reset, 1);
1008
-	usleep_range(10000, 11000);
1009
-	gpiod_set_value(serdes->reset, 0);
947
+		irq_set_status_flags(serdes->irq, IRQ_NOAUTOEN);
948
+		ret = devm_request_threaded_irq(dev, serdes->irq, NULL,
949
+						rk_serdes_irq_handler,
950
+						IRQF_TRIGGER_LOW |
951
+						IRQF_ONESHOT, "serdes-irq", serdes);
952
+		if (ret) {
953
+			dev_err(dev, "failed to request serdes interrupt\n");
954
+			return ret;
955
+		}
956
+	} else {
957
+		dev_warn(dev, "no support serdes irq function\n");
958
+	}
1010959 
1011
-	if (of_get_child_by_name(dev->of_node, "serdes-panel")) {
960
+	disp_np = of_get_child_by_name(dev->of_node, "serdes-panel");
961
+	if (disp_np) {
1012962 		serdes->stream_type = STREAM_DISPLAY;
1013
-		of_node_put(dev->of_node);
963
+		of_node_put(disp_np);
1014964 		dev_info(dev, "serdes display stream");
1015965 	} else {
1016966 		serdes->stream_type = STREAM_CAMERA;
....@@ -1021,7 +971,10 @@
1021971 	if (ret)
1022972 		return ret;
1023973 
1024
-	msleep(20);
974
+	if (serdes->remote_nr != 2) {
975
+		dual_lane = device_property_read_bool(dev, "dual-lane");
976
+		serdes->lane_nr = dual_lane ? 2 : 1;
977
+	}
1025978 
1026979 	ret = mfd_add_devices(dev, -1, rkx110_x120_devs, ARRAY_SIZE(rkx110_x120_devs),
1027980 			      NULL, 0, NULL);
....@@ -1030,27 +983,58 @@
1030983 		return ret;
1031984 	}
1032985 
986
+	if (serdes->supply) {
987
+		ret = regulator_enable(serdes->supply);
988
+		if (ret < 0) {
989
+			dev_err(serdes->dev, "failed to enable supply: %d\n", ret);
990
+			return ret;
991
+		}
992
+	}
993
+
994
+	gpiod_set_value(serdes->enable, 1);
995
+
996
+	gpiod_set_value(serdes->reset, 1);
997
+	usleep_range(10000, 11000);
998
+	gpiod_set_value(serdes->reset, 0);
999
+
1000
+	msleep(20);
1001
+
10331002 	rk_serdes_wait_link_ready(serdes);
10341003 
10351004 	rk_serdes_read_chip_id(serdes);
10361005 
10371006 	ret = rk_serdes_add_hwclk(serdes);
10381007 	if (ret < 0)
1039
-		return ret;
1008
+		goto err;
10401009 
10411010 	rk_serdes_set_rate(serdes, RATE_4GBPS_83M);
10421011 	rk_serdes_pinctrl_init(serdes);
10431012 	rk_serdes_passthrough_init(serdes);
1013
+	rk_serdes_irq_enable(serdes);
1014
+	enable_irq(serdes->irq);
1015
+
1016
+	if (serdes->stream_type == STREAM_DISPLAY)
1017
+		rk_serdes_display_route_init(serdes);
1018
+
10441019 out:
10451020 	rk_serdes_debugfs_init(serdes);
10461021 
10471022 	return 0;
1023
+
1024
+err:
1025
+	if (serdes->supply)
1026
+		ret = regulator_disable(serdes->supply);
1027
+
1028
+	return ret;
10481029 }
10491030 
10501031 static int rk_serdes_i2c_remove(struct i2c_client *client)
10511032 {
10521033 	struct rk_serdes *rk_serdes = i2c_get_clientdata(client);
10531034 
1035
+	if (rk_serdes->supply)
1036
+		regulator_disable(rk_serdes->supply);
1037
+
10541038 	mfd_remove_devices(rk_serdes->dev);
10551039 
10561040 	return 0;